Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1 | /* pcfread.c |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 2 | |
| 3 | FreeType font driver for pcf fonts |
| 4 | |
Werner Lemberg | 8c4120d | 2007-01-15 06:42:40 +0000 | [diff] [blame] | 5 | Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 by |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 6 | Francesco Zappa Nardelli |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 7 | |
| 8 | Permission is hereby granted, free of charge, to any person obtaining a copy |
| 9 | of this software and associated documentation files (the "Software"), to deal |
| 10 | in the Software without restriction, including without limitation the rights |
| 11 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| 12 | copies of the Software, and to permit persons to whom the Software is |
| 13 | furnished to do so, subject to the following conditions: |
| 14 | |
| 15 | The above copyright notice and this permission notice shall be included in |
| 16 | all copies or substantial portions of the Software. |
| 17 | |
| 18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 20 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 21 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 22 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 23 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| 24 | THE SOFTWARE. |
| 25 | */ |
| 26 | |
| 27 | |
| 28 | #include <ft2build.h> |
| 29 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 30 | #include FT_INTERNAL_DEBUG_H |
| 31 | #include FT_INTERNAL_STREAM_H |
| 32 | #include FT_INTERNAL_OBJECTS_H |
| 33 | |
David Turner | 8d3a401 | 2001-03-20 11:14:24 +0000 | [diff] [blame] | 34 | #include "pcf.h" |
Werner Lemberg | 499053c | 2003-06-07 04:02:21 +0000 | [diff] [blame] | 35 | #include "pcfdrivr.h" |
David Turner | 2f70965 | 2003-01-22 22:45:28 +0000 | [diff] [blame] | 36 | #include "pcfread.h" |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 37 | |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 38 | #include "pcferror.h" |
| 39 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 40 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 41 | /*************************************************************************/ |
| 42 | /* */ |
| 43 | /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ |
| 44 | /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ |
| 45 | /* messages during execution. */ |
| 46 | /* */ |
| 47 | #undef FT_COMPONENT |
| 48 | #define FT_COMPONENT trace_pcfread |
| 49 | |
| 50 | |
| 51 | #if defined( FT_DEBUG_LEVEL_TRACE ) |
David Turner | 10bf05a | 2004-04-21 14:30:37 +0000 | [diff] [blame] | 52 | static const char* const tableNames[] = |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 53 | { |
| 54 | "prop", "accl", "mtrcs", "bmps", "imtrcs", |
| 55 | "enc", "swidth", "names", "accel" |
| 56 | }; |
| 57 | #endif |
| 58 | |
| 59 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 60 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 61 | const FT_Frame_Field pcf_toc_header[] = |
| 62 | { |
| 63 | #undef FT_STRUCTURE |
| 64 | #define FT_STRUCTURE PCF_TocRec |
| 65 | |
| 66 | FT_FRAME_START( 8 ), |
| 67 | FT_FRAME_ULONG_LE( version ), |
| 68 | FT_FRAME_ULONG_LE( count ), |
| 69 | FT_FRAME_END |
| 70 | }; |
| 71 | |
| 72 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 73 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 74 | const FT_Frame_Field pcf_table_header[] = |
| 75 | { |
| 76 | #undef FT_STRUCTURE |
| 77 | #define FT_STRUCTURE PCF_TableRec |
| 78 | |
| 79 | FT_FRAME_START( 16 ), |
| 80 | FT_FRAME_ULONG_LE( type ), |
| 81 | FT_FRAME_ULONG_LE( format ), |
| 82 | FT_FRAME_ULONG_LE( size ), |
| 83 | FT_FRAME_ULONG_LE( offset ), |
| 84 | FT_FRAME_END |
| 85 | }; |
| 86 | |
| 87 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 88 | static FT_Error |
| 89 | pcf_read_TOC( FT_Stream stream, |
| 90 | PCF_Face face ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 91 | { |
| 92 | FT_Error error; |
| 93 | PCF_Toc toc = &face->toc; |
| 94 | PCF_Table tables; |
| 95 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 96 | FT_Memory memory = FT_FACE(face)->memory; |
| 97 | FT_UInt n; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 98 | |
| 99 | |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 100 | if ( FT_STREAM_SEEK ( 0 ) || |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 101 | FT_STREAM_READ_FIELDS ( pcf_toc_header, toc ) ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 102 | return PCF_Err_Cannot_Open_Resource; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 103 | |
David Turner | 58609c4 | 2005-03-15 23:31:48 +0000 | [diff] [blame] | 104 | if ( toc->version != PCF_FILE_VERSION || |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 105 | toc->count > FT_ARRAY_MAX( face->toc.tables ) || |
| 106 | toc->count == 0 ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 107 | return PCF_Err_Invalid_File_Format; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 108 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 109 | if ( FT_NEW_ARRAY( face->toc.tables, toc->count ) ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 110 | return PCF_Err_Out_Of_Memory; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 111 | |
| 112 | tables = face->toc.tables; |
Werner Lemberg | c3b2160 | 2001-12-05 01:22:05 +0000 | [diff] [blame] | 113 | for ( n = 0; n < toc->count; n++ ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 114 | { |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 115 | if ( FT_STREAM_READ_FIELDS( pcf_table_header, tables ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 116 | goto Exit; |
| 117 | tables++; |
| 118 | } |
| 119 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 120 | /* Sort tables and check for overlaps. Because they are almost */ |
| 121 | /* always ordered already, an in-place bubble sort with simultaneous */ |
| 122 | /* boundary checking seems appropriate. */ |
| 123 | tables = face->toc.tables; |
| 124 | |
| 125 | for ( n = 0; n < toc->count - 1; n++ ) |
| 126 | { |
| 127 | FT_UInt i, have_change; |
| 128 | |
| 129 | |
| 130 | have_change = 0; |
| 131 | |
| 132 | for ( i = 0; i < toc->count - 1 - n; i++ ) |
| 133 | { |
| 134 | PCF_TableRec tmp; |
| 135 | |
| 136 | |
| 137 | if ( tables[i].offset > tables[i + 1].offset ) |
| 138 | { |
| 139 | tmp = tables[i]; |
| 140 | tables[i] = tables[i + 1]; |
| 141 | tables[i + 1] = tmp; |
| 142 | |
| 143 | have_change = 1; |
| 144 | } |
| 145 | |
| 146 | if ( ( tables[i].size > tables[i + 1].offset ) || |
| 147 | ( tables[i].offset > tables[i + 1].offset - tables[i].size ) ) |
| 148 | return PCF_Err_Invalid_Offset; |
| 149 | } |
| 150 | |
| 151 | if ( !have_change ) |
| 152 | break; |
| 153 | } |
| 154 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 155 | #if defined( FT_DEBUG_LEVEL_TRACE ) |
| 156 | |
| 157 | { |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 158 | FT_UInt i, j; |
| 159 | const char* name = "?"; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 160 | |
| 161 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 162 | FT_TRACE4(( "pcf_read_TOC:\n" )); |
| 163 | |
| 164 | FT_TRACE4(( " number of tables: %ld\n", face->toc.count )); |
| 165 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 166 | tables = face->toc.tables; |
| 167 | for ( i = 0; i < toc->count; i++ ) |
| 168 | { |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 169 | for ( j = 0; j < sizeof ( tableNames ) / sizeof ( tableNames[0] ); |
| 170 | j++ ) |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 171 | if ( tables[i].type == (FT_UInt)( 1 << j ) ) |
Werner Lemberg | c3b2160 | 2001-12-05 01:22:05 +0000 | [diff] [blame] | 172 | name = tableNames[j]; |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 173 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 174 | FT_TRACE4(( " %d: type=%s, format=0x%X, " |
| 175 | "size=%ld (0x%lX), offset=%ld (0x%lX)\n", |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 176 | i, name, |
| 177 | tables[i].format, |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 178 | tables[i].size, tables[i].size, |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 179 | tables[i].offset, tables[i].offset )); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 180 | } |
| 181 | } |
| 182 | |
| 183 | #endif |
| 184 | |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 185 | return PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 186 | |
| 187 | Exit: |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 188 | FT_FREE( face->toc.tables ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 189 | return error; |
| 190 | } |
| 191 | |
| 192 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 193 | #define PCF_METRIC_SIZE 12 |
| 194 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 195 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 196 | const FT_Frame_Field pcf_metric_header[] = |
| 197 | { |
| 198 | #undef FT_STRUCTURE |
| 199 | #define FT_STRUCTURE PCF_MetricRec |
| 200 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 201 | FT_FRAME_START( PCF_METRIC_SIZE ), |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 202 | FT_FRAME_SHORT_LE( leftSideBearing ), |
| 203 | FT_FRAME_SHORT_LE( rightSideBearing ), |
| 204 | FT_FRAME_SHORT_LE( characterWidth ), |
| 205 | FT_FRAME_SHORT_LE( ascent ), |
| 206 | FT_FRAME_SHORT_LE( descent ), |
| 207 | FT_FRAME_SHORT_LE( attributes ), |
| 208 | FT_FRAME_END |
| 209 | }; |
| 210 | |
| 211 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 212 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 213 | const FT_Frame_Field pcf_metric_msb_header[] = |
| 214 | { |
| 215 | #undef FT_STRUCTURE |
| 216 | #define FT_STRUCTURE PCF_MetricRec |
| 217 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 218 | FT_FRAME_START( PCF_METRIC_SIZE ), |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 219 | FT_FRAME_SHORT( leftSideBearing ), |
| 220 | FT_FRAME_SHORT( rightSideBearing ), |
| 221 | FT_FRAME_SHORT( characterWidth ), |
| 222 | FT_FRAME_SHORT( ascent ), |
| 223 | FT_FRAME_SHORT( descent ), |
| 224 | FT_FRAME_SHORT( attributes ), |
| 225 | FT_FRAME_END |
| 226 | }; |
| 227 | |
| 228 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 229 | #define PCF_COMPRESSED_METRIC_SIZE 5 |
| 230 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 231 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 232 | const FT_Frame_Field pcf_compressed_metric_header[] = |
| 233 | { |
| 234 | #undef FT_STRUCTURE |
| 235 | #define FT_STRUCTURE PCF_Compressed_MetricRec |
| 236 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 237 | FT_FRAME_START( PCF_COMPRESSED_METRIC_SIZE ), |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 238 | FT_FRAME_BYTE( leftSideBearing ), |
| 239 | FT_FRAME_BYTE( rightSideBearing ), |
| 240 | FT_FRAME_BYTE( characterWidth ), |
| 241 | FT_FRAME_BYTE( ascent ), |
| 242 | FT_FRAME_BYTE( descent ), |
| 243 | FT_FRAME_END |
| 244 | }; |
| 245 | |
| 246 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 247 | static FT_Error |
| 248 | pcf_get_metric( FT_Stream stream, |
| 249 | FT_ULong format, |
| 250 | PCF_Metric metric ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 251 | { |
Werner Lemberg | 60a1fab | 2002-02-08 06:23:50 +0000 | [diff] [blame] | 252 | FT_Error error = PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 253 | |
| 254 | |
| 255 | if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) ) |
| 256 | { |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 257 | const FT_Frame_Field* fields; |
| 258 | |
| 259 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 260 | /* parsing normal metrics */ |
| 261 | fields = PCF_BYTE_ORDER( format ) == MSBFirst |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 262 | ? pcf_metric_msb_header |
| 263 | : pcf_metric_header; |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 264 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 265 | /* the following sets `error' but doesn't return in case of failure */ |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 266 | (void)FT_STREAM_READ_FIELDS( fields, metric ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 267 | } |
| 268 | else |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 269 | { |
| 270 | PCF_Compressed_MetricRec compr; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 271 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 272 | |
| 273 | /* parsing compressed metrics */ |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 274 | if ( FT_STREAM_READ_FIELDS( pcf_compressed_metric_header, &compr ) ) |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 275 | goto Exit; |
| 276 | |
| 277 | metric->leftSideBearing = (FT_Short)( compr.leftSideBearing - 0x80 ); |
| 278 | metric->rightSideBearing = (FT_Short)( compr.rightSideBearing - 0x80 ); |
| 279 | metric->characterWidth = (FT_Short)( compr.characterWidth - 0x80 ); |
| 280 | metric->ascent = (FT_Short)( compr.ascent - 0x80 ); |
| 281 | metric->descent = (FT_Short)( compr.descent - 0x80 ); |
| 282 | metric->attributes = 0; |
| 283 | } |
| 284 | |
| 285 | Exit: |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 286 | return error; |
| 287 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 288 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 289 | |
| 290 | static FT_Error |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 291 | pcf_seek_to_table_type( FT_Stream stream, |
| 292 | PCF_Table tables, |
| 293 | FT_Int ntables, |
| 294 | FT_ULong type, |
| 295 | FT_ULong *aformat, |
| 296 | FT_ULong *asize ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 297 | { |
Werner Lemberg | 319c00d | 2003-04-23 19:48:24 +0000 | [diff] [blame] | 298 | FT_Error error = PCF_Err_Invalid_File_Format; |
Werner Lemberg | b5349a9 | 2002-02-19 16:30:15 +0000 | [diff] [blame] | 299 | FT_Int i; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 300 | |
| 301 | |
| 302 | for ( i = 0; i < ntables; i++ ) |
| 303 | if ( tables[i].type == type ) |
| 304 | { |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 305 | if ( stream->pos > tables[i].offset ) |
| 306 | { |
Werner Lemberg | 319c00d | 2003-04-23 19:48:24 +0000 | [diff] [blame] | 307 | error = PCF_Err_Invalid_Stream_Skip; |
| 308 | goto Fail; |
| 309 | } |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 310 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 311 | if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) ) |
| 312 | { |
Werner Lemberg | 319c00d | 2003-04-23 19:48:24 +0000 | [diff] [blame] | 313 | error = PCF_Err_Invalid_Stream_Skip; |
| 314 | goto Fail; |
| 315 | } |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 316 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 317 | *asize = tables[i].size; |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 318 | *aformat = tables[i].format; |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 319 | |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 320 | return PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 321 | } |
| 322 | |
Werner Lemberg | 319c00d | 2003-04-23 19:48:24 +0000 | [diff] [blame] | 323 | Fail: |
Werner Lemberg | 8c4120d | 2007-01-15 06:42:40 +0000 | [diff] [blame] | 324 | *asize = 0; |
Werner Lemberg | 319c00d | 2003-04-23 19:48:24 +0000 | [diff] [blame] | 325 | return error; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 329 | static FT_Bool |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 330 | pcf_has_table_type( PCF_Table tables, |
| 331 | FT_Int ntables, |
| 332 | FT_ULong type ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 333 | { |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 334 | FT_Int i; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 335 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 336 | |
| 337 | for ( i = 0; i < ntables; i++ ) |
| 338 | if ( tables[i].type == type ) |
| 339 | return TRUE; |
| 340 | |
| 341 | return FALSE; |
| 342 | } |
| 343 | |
| 344 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 345 | #define PCF_PROPERTY_SIZE 9 |
| 346 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 347 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 348 | const FT_Frame_Field pcf_property_header[] = |
| 349 | { |
| 350 | #undef FT_STRUCTURE |
| 351 | #define FT_STRUCTURE PCF_ParsePropertyRec |
| 352 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 353 | FT_FRAME_START( PCF_PROPERTY_SIZE ), |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 354 | FT_FRAME_LONG_LE( name ), |
| 355 | FT_FRAME_BYTE ( isString ), |
| 356 | FT_FRAME_LONG_LE( value ), |
| 357 | FT_FRAME_END |
| 358 | }; |
| 359 | |
| 360 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 361 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 362 | const FT_Frame_Field pcf_property_msb_header[] = |
| 363 | { |
| 364 | #undef FT_STRUCTURE |
| 365 | #define FT_STRUCTURE PCF_ParsePropertyRec |
| 366 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 367 | FT_FRAME_START( PCF_PROPERTY_SIZE ), |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 368 | FT_FRAME_LONG( name ), |
| 369 | FT_FRAME_BYTE( isString ), |
| 370 | FT_FRAME_LONG( value ), |
| 371 | FT_FRAME_END |
| 372 | }; |
| 373 | |
| 374 | |
David Turner | 2f70965 | 2003-01-22 22:45:28 +0000 | [diff] [blame] | 375 | FT_LOCAL_DEF( PCF_Property ) |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 376 | pcf_find_property( PCF_Face face, |
| 377 | const FT_String* prop ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 378 | { |
| 379 | PCF_Property properties = face->properties; |
| 380 | FT_Bool found = 0; |
| 381 | int i; |
| 382 | |
| 383 | |
| 384 | for ( i = 0 ; i < face->nprops && !found; i++ ) |
| 385 | { |
David Turner | d15bc0d | 2002-04-12 09:31:48 +0000 | [diff] [blame] | 386 | if ( !ft_strcmp( properties[i].name, prop ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 387 | found = 1; |
| 388 | } |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 389 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 390 | if ( found ) |
| 391 | return properties + i - 1; |
| 392 | else |
| 393 | return NULL; |
| 394 | } |
| 395 | |
| 396 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 397 | static FT_Error |
| 398 | pcf_get_properties( FT_Stream stream, |
| 399 | PCF_Face face ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 400 | { |
| 401 | PCF_ParseProperty props = 0; |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 402 | PCF_Property properties; |
| 403 | FT_UInt nprops, i; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 404 | FT_ULong format, size; |
| 405 | FT_Error error; |
| 406 | FT_Memory memory = FT_FACE(face)->memory; |
| 407 | FT_ULong string_size; |
| 408 | FT_String* strings = 0; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 409 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 410 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 411 | error = pcf_seek_to_table_type( stream, |
| 412 | face->toc.tables, |
| 413 | face->toc.count, |
| 414 | PCF_PROPERTIES, |
| 415 | &format, |
| 416 | &size ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 417 | if ( error ) |
| 418 | goto Bail; |
| 419 | |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 420 | if ( FT_READ_ULONG_LE( format ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 421 | goto Bail; |
| 422 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 423 | FT_TRACE4(( "pcf_get_properties:\n" )); |
| 424 | |
| 425 | FT_TRACE4(( " format = %ld\n", format )); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 426 | |
| 427 | if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) ) |
| 428 | goto Bail; |
| 429 | |
| 430 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 431 | (void)FT_READ_ULONG( nprops ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 432 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 433 | (void)FT_READ_ULONG_LE( nprops ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 434 | if ( error ) |
| 435 | goto Bail; |
| 436 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 437 | FT_TRACE4(( " nprop = %d\n", nprops )); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 438 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 439 | /* rough estimate */ |
| 440 | if ( nprops > size / PCF_PROPERTY_SIZE ) |
| 441 | { |
| 442 | error = PCF_Err_Invalid_Table; |
| 443 | goto Bail; |
| 444 | } |
| 445 | |
| 446 | face->nprops = nprops; |
| 447 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 448 | if ( FT_NEW_ARRAY( props, nprops ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 449 | goto Bail; |
| 450 | |
| 451 | for ( i = 0; i < nprops; i++ ) |
| 452 | { |
| 453 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 454 | { |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 455 | if ( FT_STREAM_READ_FIELDS( pcf_property_msb_header, props + i ) ) |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 456 | goto Bail; |
| 457 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 458 | else |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 459 | { |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 460 | if ( FT_STREAM_READ_FIELDS( pcf_property_header, props + i ) ) |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 461 | goto Bail; |
| 462 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 463 | } |
| 464 | |
| 465 | /* pad the property array */ |
| 466 | /* */ |
| 467 | /* clever here - nprops is the same as the number of odd-units read, */ |
| 468 | /* as only isStringProp are odd length (Keith Packard) */ |
| 469 | /* */ |
| 470 | if ( nprops & 3 ) |
| 471 | { |
| 472 | i = 4 - ( nprops & 3 ); |
David Turner | 53b3fa1 | 2002-02-24 05:26:57 +0000 | [diff] [blame] | 473 | FT_Stream_Skip( stream, i ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 474 | } |
| 475 | |
| 476 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 477 | (void)FT_READ_ULONG( string_size ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 478 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 479 | (void)FT_READ_ULONG_LE( string_size ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 480 | if ( error ) |
| 481 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 482 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 483 | FT_TRACE4(( " string_size = %ld\n", string_size )); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 484 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 485 | /* rough estimate */ |
| 486 | if ( string_size > size - nprops * PCF_PROPERTY_SIZE ) |
| 487 | { |
| 488 | error = PCF_Err_Invalid_Table; |
| 489 | goto Bail; |
| 490 | } |
| 491 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 492 | if ( FT_NEW_ARRAY( strings, string_size ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 493 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 494 | |
David Turner | 53b3fa1 | 2002-02-24 05:26:57 +0000 | [diff] [blame] | 495 | error = FT_Stream_Read( stream, (FT_Byte*)strings, string_size ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 496 | if ( error ) |
| 497 | goto Bail; |
| 498 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 499 | if ( FT_NEW_ARRAY( properties, nprops ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 500 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 501 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 502 | face->properties = properties; |
| 503 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 504 | for ( i = 0; i < nprops; i++ ) |
| 505 | { |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 506 | FT_Long name_offset = props[i].name; |
| 507 | |
| 508 | |
| 509 | if ( ( name_offset < 0 ) || |
| 510 | ( (FT_ULong)name_offset > string_size ) ) |
| 511 | { |
| 512 | error = PCF_Err_Invalid_Offset; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 513 | goto Bail; |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 514 | } |
| 515 | |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 516 | if ( FT_STRDUP( properties[i].name, strings + name_offset ) ) |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 517 | goto Bail; |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 518 | |
| 519 | FT_TRACE4(( " %s:", properties[i].name )); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 520 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 521 | properties[i].isString = props[i].isString; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 522 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 523 | if ( props[i].isString ) |
| 524 | { |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 525 | FT_Long value_offset = props[i].value; |
| 526 | |
| 527 | |
| 528 | if ( ( value_offset < 0 ) || |
| 529 | ( (FT_ULong)value_offset > string_size ) ) |
| 530 | { |
| 531 | error = PCF_Err_Invalid_Offset; |
| 532 | goto Bail; |
| 533 | } |
| 534 | |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 535 | if ( FT_STRDUP( properties[i].value.atom, strings + value_offset ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 536 | goto Bail; |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 537 | |
| 538 | FT_TRACE4(( " `%s'\n", properties[i].value.atom )); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 539 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 540 | else |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 541 | { |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 542 | properties[i].value.integer = props[i].value; |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 543 | |
| 544 | FT_TRACE4(( " %d\n", properties[i].value.integer )); |
| 545 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 546 | } |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 547 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 548 | error = PCF_Err_Ok; |
Werner Lemberg | 9b774e2 | 2007-01-16 06:11:27 +0000 | [diff] [blame] | 549 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 550 | Bail: |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 551 | FT_FREE( props ); |
| 552 | FT_FREE( strings ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 553 | |
| 554 | return error; |
| 555 | } |
| 556 | |
| 557 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 558 | static FT_Error |
| 559 | pcf_get_metrics( FT_Stream stream, |
| 560 | PCF_Face face ) |
| 561 | { |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 562 | FT_Error error = PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 563 | FT_Memory memory = FT_FACE(face)->memory; |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 564 | FT_ULong format, size; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 565 | PCF_Metric metrics = 0; |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 566 | FT_ULong nmetrics, i; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 567 | |
| 568 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 569 | error = pcf_seek_to_table_type( stream, |
Werner Lemberg | 60a1fab | 2002-02-08 06:23:50 +0000 | [diff] [blame] | 570 | face->toc.tables, |
| 571 | face->toc.count, |
| 572 | PCF_METRICS, |
| 573 | &format, |
| 574 | &size ); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 575 | if ( error ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 576 | return error; |
| 577 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 578 | if ( FT_READ_ULONG_LE( format ) ) |
| 579 | goto Bail; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 580 | |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 581 | if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) && |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 582 | !PCF_FORMAT_MATCH( format, PCF_COMPRESSED_METRICS ) ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 583 | return PCF_Err_Invalid_File_Format; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 584 | |
| 585 | if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) ) |
| 586 | { |
| 587 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 588 | (void)FT_READ_ULONG( nmetrics ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 589 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 590 | (void)FT_READ_ULONG_LE( nmetrics ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 591 | } |
| 592 | else |
| 593 | { |
| 594 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 595 | (void)FT_READ_USHORT( nmetrics ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 596 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 597 | (void)FT_READ_USHORT_LE( nmetrics ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 598 | } |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 599 | if ( error ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 600 | return PCF_Err_Invalid_File_Format; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 601 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 602 | face->nmetrics = nmetrics; |
| 603 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 604 | FT_TRACE4(( "pcf_get_metrics:\n" )); |
| 605 | |
| 606 | FT_TRACE4(( " number of metrics: %d\n", nmetrics )); |
| 607 | |
| 608 | /* rough estimate */ |
| 609 | if ( PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) ) |
| 610 | { |
| 611 | if ( nmetrics > size / PCF_METRIC_SIZE ) |
| 612 | return PCF_Err_Invalid_Table; |
| 613 | } |
| 614 | else |
| 615 | { |
| 616 | if ( nmetrics > size / PCF_COMPRESSED_METRIC_SIZE ) |
| 617 | return PCF_Err_Invalid_Table; |
| 618 | } |
| 619 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 620 | if ( FT_NEW_ARRAY( face->metrics, nmetrics ) ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 621 | return PCF_Err_Out_Of_Memory; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 622 | |
| 623 | metrics = face->metrics; |
| 624 | for ( i = 0; i < nmetrics; i++ ) |
| 625 | { |
| 626 | pcf_get_metric( stream, format, metrics + i ); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 627 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 628 | metrics[i].bits = 0; |
| 629 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 630 | FT_TRACE5(( " idx %d: width=%d, " |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 631 | "lsb=%d, rsb=%d, ascent=%d, descent=%d, swidth=%d\n", |
| 632 | i, |
| 633 | ( metrics + i )->characterWidth, |
| 634 | ( metrics + i )->leftSideBearing, |
| 635 | ( metrics + i )->rightSideBearing, |
| 636 | ( metrics + i )->ascent, |
| 637 | ( metrics + i )->descent, |
| 638 | ( metrics + i )->attributes )); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 639 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 640 | if ( error ) |
| 641 | break; |
| 642 | } |
| 643 | |
| 644 | if ( error ) |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 645 | FT_FREE( face->metrics ); |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 646 | |
| 647 | Bail: |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 648 | return error; |
| 649 | } |
| 650 | |
| 651 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 652 | static FT_Error |
| 653 | pcf_get_bitmaps( FT_Stream stream, |
| 654 | PCF_Face face ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 655 | { |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 656 | FT_Error error = PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 657 | FT_Memory memory = FT_FACE(face)->memory; |
| 658 | FT_Long* offsets; |
| 659 | FT_Long bitmapSizes[GLYPHPADOPTIONS]; |
| 660 | FT_ULong format, size; |
David Turner | 0b3a991 | 2001-06-19 15:45:48 +0000 | [diff] [blame] | 661 | int nbitmaps, i, sizebitmaps = 0; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 662 | |
| 663 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 664 | error = pcf_seek_to_table_type( stream, |
| 665 | face->toc.tables, |
| 666 | face->toc.count, |
| 667 | PCF_BITMAPS, |
| 668 | &format, |
| 669 | &size ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 670 | if ( error ) |
| 671 | return error; |
| 672 | |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 673 | error = FT_Stream_EnterFrame( stream, 8 ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 674 | if ( error ) |
| 675 | return error; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 676 | |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 677 | format = FT_GET_ULONG_LE(); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 678 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 679 | nbitmaps = FT_GET_ULONG(); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 680 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 681 | nbitmaps = FT_GET_ULONG_LE(); |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 682 | |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 683 | FT_Stream_ExitFrame( stream ); |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 684 | |
| 685 | if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) ) |
| 686 | return PCF_Err_Invalid_File_Format; |
| 687 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 688 | FT_TRACE4(( "pcf_get_bitmaps:\n" )); |
| 689 | |
| 690 | FT_TRACE4(( " number of bitmaps: %d\n", nbitmaps )); |
| 691 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 692 | if ( nbitmaps != face->nmetrics ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 693 | return PCF_Err_Invalid_File_Format; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 694 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 695 | if ( FT_NEW_ARRAY( offsets, nbitmaps ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 696 | return error; |
| 697 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 698 | for ( i = 0; i < nbitmaps; i++ ) |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 699 | { |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 700 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 701 | (void)FT_READ_LONG( offsets[i] ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 702 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 703 | (void)FT_READ_LONG_LE( offsets[i] ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 704 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 705 | FT_TRACE5(( " bitmap %d: offset %ld (0x%lX)\n", |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 706 | i, offsets[i], offsets[i] )); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 707 | } |
| 708 | if ( error ) |
| 709 | goto Bail; |
| 710 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 711 | for ( i = 0; i < GLYPHPADOPTIONS; i++ ) |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 712 | { |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 713 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 714 | (void)FT_READ_LONG( bitmapSizes[i] ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 715 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 716 | (void)FT_READ_LONG_LE( bitmapSizes[i] ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 717 | if ( error ) |
| 718 | goto Bail; |
| 719 | |
| 720 | sizebitmaps = bitmapSizes[PCF_GLYPH_PAD_INDEX( format )]; |
| 721 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 722 | FT_TRACE4(( " padding %d implies a size of %ld\n", i, bitmapSizes[i] )); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 723 | } |
| 724 | |
| 725 | FT_TRACE4(( " %d bitmaps, padding index %ld\n", |
| 726 | nbitmaps, |
| 727 | PCF_GLYPH_PAD_INDEX( format ) )); |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 728 | FT_TRACE4(( " bitmap size = %d\n", sizebitmaps )); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 729 | |
Werner Lemberg | b5349a9 | 2002-02-19 16:30:15 +0000 | [diff] [blame] | 730 | FT_UNUSED( sizebitmaps ); /* only used for debugging */ |
| 731 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 732 | for ( i = 0; i < nbitmaps; i++ ) |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 733 | { |
| 734 | /* rough estimate */ |
| 735 | if ( ( offsets[i] < 0 ) || |
| 736 | ( (FT_ULong)offsets[i] > size ) ) |
| 737 | { |
| 738 | FT_ERROR(( "pcf_get_bitmaps:")); |
| 739 | FT_ERROR(( " invalid offset to bitmap data of glyph %d\n", i )); |
| 740 | } |
| 741 | else |
| 742 | face->metrics[i].bits = stream->pos + offsets[i]; |
| 743 | } |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 744 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 745 | face->bitmapsFormat = format; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 746 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 747 | Bail: |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 748 | FT_FREE( offsets ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 749 | return error; |
| 750 | } |
| 751 | |
| 752 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 753 | static FT_Error |
| 754 | pcf_get_encodings( FT_Stream stream, |
| 755 | PCF_Face face ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 756 | { |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 757 | FT_Error error = PCF_Err_Ok; |
| 758 | FT_Memory memory = FT_FACE(face)->memory; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 759 | FT_ULong format, size; |
| 760 | int firstCol, lastCol; |
| 761 | int firstRow, lastRow; |
| 762 | int nencoding, encodingOffset; |
| 763 | int i, j; |
| 764 | PCF_Encoding tmpEncoding, encoding = 0; |
| 765 | |
| 766 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 767 | error = pcf_seek_to_table_type( stream, |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 768 | face->toc.tables, |
| 769 | face->toc.count, |
| 770 | PCF_BDF_ENCODINGS, |
| 771 | &format, |
| 772 | &size ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 773 | if ( error ) |
| 774 | return error; |
| 775 | |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 776 | error = FT_Stream_EnterFrame( stream, 14 ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 777 | if ( error ) |
| 778 | return error; |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 779 | |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 780 | format = FT_GET_ULONG_LE(); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 781 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 782 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
| 783 | { |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 784 | firstCol = FT_GET_SHORT(); |
| 785 | lastCol = FT_GET_SHORT(); |
| 786 | firstRow = FT_GET_SHORT(); |
| 787 | lastRow = FT_GET_SHORT(); |
| 788 | face->defaultChar = FT_GET_SHORT(); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 789 | } |
| 790 | else |
| 791 | { |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 792 | firstCol = FT_GET_SHORT_LE(); |
| 793 | lastCol = FT_GET_SHORT_LE(); |
| 794 | firstRow = FT_GET_SHORT_LE(); |
| 795 | lastRow = FT_GET_SHORT_LE(); |
| 796 | face->defaultChar = FT_GET_SHORT_LE(); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 797 | } |
| 798 | |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 799 | FT_Stream_ExitFrame( stream ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 800 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 801 | if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) ) |
| 802 | return PCF_Err_Invalid_File_Format; |
| 803 | |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 804 | FT_TRACE4(( "pdf_get_encodings:\n" )); |
| 805 | |
| 806 | FT_TRACE4(( " firstCol %d, lastCol %d, firstRow %d, lastRow %d\n", |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 807 | firstCol, lastCol, firstRow, lastRow )); |
| 808 | |
| 809 | nencoding = ( lastCol - firstCol + 1 ) * ( lastRow - firstRow + 1 ); |
| 810 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 811 | if ( FT_NEW_ARRAY( tmpEncoding, nencoding ) ) |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 812 | return PCF_Err_Out_Of_Memory; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 813 | |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 814 | error = FT_Stream_EnterFrame( stream, 2 * nencoding ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 815 | if ( error ) |
| 816 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 817 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 818 | for ( i = 0, j = 0 ; i < nencoding; i++ ) |
| 819 | { |
| 820 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 821 | encodingOffset = FT_GET_SHORT(); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 822 | else |
David Turner | a890c29 | 2002-03-22 12:55:23 +0000 | [diff] [blame] | 823 | encodingOffset = FT_GET_SHORT_LE(); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 824 | |
David Turner | 3b7049f | 2001-07-07 16:12:14 +0000 | [diff] [blame] | 825 | if ( encodingOffset != -1 ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 826 | { |
| 827 | tmpEncoding[j].enc = ( ( ( i / ( lastCol - firstCol + 1 ) ) + |
| 828 | firstRow ) * 256 ) + |
| 829 | ( ( i % ( lastCol - firstCol + 1 ) ) + |
| 830 | firstCol ); |
| 831 | |
David Turner | 8edbcab | 2001-06-19 08:28:24 +0000 | [diff] [blame] | 832 | tmpEncoding[j].glyph = (FT_Short)encodingOffset; |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 833 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 834 | FT_TRACE5(( " code %d (0x%04X): idx %d\n", |
Werner Lemberg | 83efe77 | 2004-06-22 06:24:09 +0000 | [diff] [blame] | 835 | tmpEncoding[j].enc, tmpEncoding[j].enc, |
| 836 | tmpEncoding[j].glyph )); |
| 837 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 838 | j++; |
| 839 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 840 | } |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 841 | FT_Stream_ExitFrame( stream ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 842 | |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 843 | if ( FT_NEW_ARRAY( encoding, j ) ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 844 | goto Bail; |
| 845 | |
| 846 | for ( i = 0; i < j; i++ ) |
| 847 | { |
| 848 | encoding[i].enc = tmpEncoding[i].enc; |
| 849 | encoding[i].glyph = tmpEncoding[i].glyph; |
| 850 | } |
| 851 | |
| 852 | face->nencodings = j; |
| 853 | face->encodings = encoding; |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 854 | FT_FREE( tmpEncoding ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 855 | |
| 856 | return error; |
| 857 | |
| 858 | Bail: |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 859 | FT_FREE( encoding ); |
| 860 | FT_FREE( tmpEncoding ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 861 | return error; |
| 862 | } |
| 863 | |
| 864 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 865 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 866 | const FT_Frame_Field pcf_accel_header[] = |
| 867 | { |
| 868 | #undef FT_STRUCTURE |
| 869 | #define FT_STRUCTURE PCF_AccelRec |
| 870 | |
| 871 | FT_FRAME_START( 20 ), |
| 872 | FT_FRAME_BYTE ( noOverlap ), |
| 873 | FT_FRAME_BYTE ( constantMetrics ), |
| 874 | FT_FRAME_BYTE ( terminalFont ), |
| 875 | FT_FRAME_BYTE ( constantWidth ), |
| 876 | FT_FRAME_BYTE ( inkInside ), |
| 877 | FT_FRAME_BYTE ( inkMetrics ), |
| 878 | FT_FRAME_BYTE ( drawDirection ), |
| 879 | FT_FRAME_SKIP_BYTES( 1 ), |
| 880 | FT_FRAME_LONG_LE ( fontAscent ), |
| 881 | FT_FRAME_LONG_LE ( fontDescent ), |
| 882 | FT_FRAME_LONG_LE ( maxOverlap ), |
| 883 | FT_FRAME_END |
| 884 | }; |
| 885 | |
| 886 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 887 | static |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 888 | const FT_Frame_Field pcf_accel_msb_header[] = |
| 889 | { |
| 890 | #undef FT_STRUCTURE |
| 891 | #define FT_STRUCTURE PCF_AccelRec |
| 892 | |
| 893 | FT_FRAME_START( 20 ), |
| 894 | FT_FRAME_BYTE ( noOverlap ), |
| 895 | FT_FRAME_BYTE ( constantMetrics ), |
| 896 | FT_FRAME_BYTE ( terminalFont ), |
| 897 | FT_FRAME_BYTE ( constantWidth ), |
| 898 | FT_FRAME_BYTE ( inkInside ), |
| 899 | FT_FRAME_BYTE ( inkMetrics ), |
| 900 | FT_FRAME_BYTE ( drawDirection ), |
| 901 | FT_FRAME_SKIP_BYTES( 1 ), |
| 902 | FT_FRAME_LONG ( fontAscent ), |
| 903 | FT_FRAME_LONG ( fontDescent ), |
| 904 | FT_FRAME_LONG ( maxOverlap ), |
| 905 | FT_FRAME_END |
| 906 | }; |
| 907 | |
| 908 | |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 909 | static FT_Error |
| 910 | pcf_get_accel( FT_Stream stream, |
| 911 | PCF_Face face, |
| 912 | FT_ULong type ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 913 | { |
| 914 | FT_ULong format, size; |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 915 | FT_Error error = PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 916 | PCF_Accel accel = &face->accel; |
| 917 | |
| 918 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 919 | error = pcf_seek_to_table_type( stream, |
| 920 | face->toc.tables, |
| 921 | face->toc.count, |
| 922 | type, |
| 923 | &format, |
| 924 | &size ); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 925 | if ( error ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 926 | goto Bail; |
| 927 | |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 928 | if ( FT_READ_ULONG_LE( format ) ) |
| 929 | goto Bail; |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 930 | |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 931 | if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) && |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 932 | !PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) ) |
| 933 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 934 | |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 935 | if ( PCF_BYTE_ORDER( format ) == MSBFirst ) |
| 936 | { |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 937 | if ( FT_STREAM_READ_FIELDS( pcf_accel_msb_header, accel ) ) |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 938 | goto Bail; |
| 939 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 940 | else |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 941 | { |
David Turner | 7d3a264 | 2002-03-20 10:49:31 +0000 | [diff] [blame] | 942 | if ( FT_STREAM_READ_FIELDS( pcf_accel_header, accel ) ) |
Werner Lemberg | 22e812a | 2001-03-11 13:11:43 +0000 | [diff] [blame] | 943 | goto Bail; |
| 944 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 945 | |
Werner Lemberg | 9928df8 | 2002-04-16 13:39:17 +0000 | [diff] [blame] | 946 | error = pcf_get_metric( stream, |
| 947 | format & ( ~PCF_FORMAT_MASK ), |
| 948 | &(accel->minbounds) ); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 949 | if ( error ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 950 | goto Bail; |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 951 | |
Werner Lemberg | 9928df8 | 2002-04-16 13:39:17 +0000 | [diff] [blame] | 952 | error = pcf_get_metric( stream, |
| 953 | format & ( ~PCF_FORMAT_MASK ), |
| 954 | &(accel->maxbounds) ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 955 | if ( error ) |
| 956 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 957 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 958 | if ( PCF_FORMAT_MATCH( format, PCF_ACCEL_W_INKBOUNDS ) ) |
| 959 | { |
Werner Lemberg | 9928df8 | 2002-04-16 13:39:17 +0000 | [diff] [blame] | 960 | error = pcf_get_metric( stream, |
| 961 | format & ( ~PCF_FORMAT_MASK ), |
| 962 | &(accel->ink_minbounds) ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 963 | if ( error ) |
| 964 | goto Bail; |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 965 | |
Werner Lemberg | 9928df8 | 2002-04-16 13:39:17 +0000 | [diff] [blame] | 966 | error = pcf_get_metric( stream, |
| 967 | format & ( ~PCF_FORMAT_MASK ), |
| 968 | &(accel->ink_maxbounds) ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 969 | if ( error ) |
| 970 | goto Bail; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 971 | } |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 972 | else |
| 973 | { |
| 974 | accel->ink_minbounds = accel->minbounds; /* I'm not sure about this */ |
| 975 | accel->ink_maxbounds = accel->maxbounds; |
| 976 | } |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 977 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 978 | Bail: |
| 979 | return error; |
| 980 | } |
| 981 | |
| 982 | |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 983 | static FT_Error |
| 984 | pcf_interpret_style( PCF_Face pcf ) |
| 985 | { |
| 986 | FT_Error error = PCF_Err_Ok; |
| 987 | FT_Face face = FT_FACE( pcf ); |
| 988 | FT_Memory memory = face->memory; |
| 989 | |
| 990 | PCF_Property prop; |
| 991 | |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 992 | int nn, len; |
| 993 | char* strings[4] = { NULL, NULL, NULL, NULL }; |
| 994 | int lengths[4]; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 995 | |
| 996 | |
| 997 | face->style_flags = 0; |
| 998 | |
| 999 | prop = pcf_find_property( pcf, "SLANT" ); |
| 1000 | if ( prop && prop->isString && |
| 1001 | ( *(prop->value.atom) == 'O' || *(prop->value.atom) == 'o' || |
| 1002 | *(prop->value.atom) == 'I' || *(prop->value.atom) == 'i' ) ) |
| 1003 | { |
| 1004 | face->style_flags |= FT_STYLE_FLAG_ITALIC; |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1005 | strings[2] = ( *(prop->value.atom) == 'O' || |
| 1006 | *(prop->value.atom) == 'o' ) ? (char *)"Oblique" |
| 1007 | : (char *)"Italic"; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1008 | } |
| 1009 | |
| 1010 | prop = pcf_find_property( pcf, "WEIGHT_NAME" ); |
| 1011 | if ( prop && prop->isString && |
| 1012 | ( *(prop->value.atom) == 'B' || *(prop->value.atom) == 'b' ) ) |
| 1013 | { |
| 1014 | face->style_flags |= FT_STYLE_FLAG_BOLD; |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1015 | strings[1] = (char *)"Bold"; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1016 | } |
| 1017 | |
| 1018 | prop = pcf_find_property( pcf, "SETWIDTH_NAME" ); |
| 1019 | if ( prop && prop->isString && |
| 1020 | *(prop->value.atom) && |
| 1021 | !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) ) |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1022 | strings[3] = (char *)(prop->value.atom); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1023 | |
| 1024 | prop = pcf_find_property( pcf, "ADD_STYLE_NAME" ); |
| 1025 | if ( prop && prop->isString && |
| 1026 | *(prop->value.atom) && |
| 1027 | !( *(prop->value.atom) == 'N' || *(prop->value.atom) == 'n' ) ) |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1028 | strings[0] = (char *)(prop->value.atom); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1029 | |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1030 | for ( len = 0, nn = 0; nn < 4; nn++ ) |
Werner Lemberg | 004f3da | 2004-07-28 00:09:02 +0000 | [diff] [blame] | 1031 | { |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1032 | lengths[nn] = 0; |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1033 | if ( strings[nn] ) |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1034 | { |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1035 | lengths[nn] = ft_strlen( strings[nn] ); |
| 1036 | len += lengths[nn] + 1; |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1037 | } |
Werner Lemberg | 004f3da | 2004-07-28 00:09:02 +0000 | [diff] [blame] | 1038 | } |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1039 | |
| 1040 | if ( len == 0 ) |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1041 | { |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1042 | strings[0] = "Regular"; |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1043 | lengths[0] = ft_strlen( strings[0] ); |
| 1044 | len = lengths[0] + 1; |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1045 | } |
| 1046 | |
| 1047 | { |
| 1048 | char* s; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1049 | |
| 1050 | |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1051 | if ( FT_ALLOC( face->style_name, len ) ) |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1052 | return error; |
| 1053 | |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1054 | s = face->style_name; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1055 | |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1056 | for ( nn = 0; nn < 4; nn++ ) |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1057 | { |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1058 | char* src = strings[nn]; |
| 1059 | int len = lengths[nn]; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1060 | |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1061 | |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1062 | if ( src == NULL ) |
| 1063 | continue; |
| 1064 | |
| 1065 | /* separate elements with a space */ |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1066 | if ( s != face->style_name ) |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1067 | *s++ = ' '; |
| 1068 | |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1069 | ft_memcpy( s, src, len ); |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1070 | |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1071 | /* need to convert spaces to dashes for */ |
| 1072 | /* add_style_name and setwidth_name */ |
| 1073 | if ( nn == 0 || nn == 3 ) |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1074 | { |
| 1075 | int mm; |
| 1076 | |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1077 | |
| 1078 | for ( mm = 0; mm < len; mm++ ) |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1079 | if (s[mm] == ' ') |
| 1080 | s[mm] = '-'; |
| 1081 | } |
| 1082 | |
| 1083 | s += len; |
| 1084 | } |
| 1085 | *s = 0; |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1086 | } |
| 1087 | |
| 1088 | return error; |
| 1089 | } |
| 1090 | |
| 1091 | |
David Turner | bc82f1b | 2002-03-01 02:26:22 +0000 | [diff] [blame] | 1092 | FT_LOCAL_DEF( FT_Error ) |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1093 | pcf_load_font( FT_Stream stream, |
| 1094 | PCF_Face face ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1095 | { |
Werner Lemberg | 1f7f0e8 | 2001-06-06 17:30:41 +0000 | [diff] [blame] | 1096 | FT_Error error = PCF_Err_Ok; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1097 | FT_Memory memory = FT_FACE(face)->memory; |
| 1098 | FT_Bool hasBDFAccelerators; |
| 1099 | |
| 1100 | |
| 1101 | error = pcf_read_TOC( stream, face ); |
| 1102 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1103 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1104 | |
| 1105 | error = pcf_get_properties( stream, face ); |
| 1106 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1107 | goto Exit; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1108 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1109 | /* Use the old accelerators if no BDF accelerators are in the file. */ |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 1110 | hasBDFAccelerators = pcf_has_table_type( face->toc.tables, |
Werner Lemberg | 60a1fab | 2002-02-08 06:23:50 +0000 | [diff] [blame] | 1111 | face->toc.count, |
| 1112 | PCF_BDF_ACCELERATORS ); |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1113 | if ( !hasBDFAccelerators ) |
| 1114 | { |
| 1115 | error = pcf_get_accel( stream, face, PCF_ACCELERATORS ); |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1116 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1117 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1118 | } |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1119 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1120 | /* metrics */ |
| 1121 | error = pcf_get_metrics( stream, face ); |
| 1122 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1123 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1124 | |
| 1125 | /* bitmaps */ |
| 1126 | error = pcf_get_bitmaps( stream, face ); |
| 1127 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1128 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1129 | |
| 1130 | /* encodings */ |
| 1131 | error = pcf_get_encodings( stream, face ); |
| 1132 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1133 | goto Exit; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1134 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1135 | /* BDF style accelerators (i.e. bounds based on encoded glyphs) */ |
| 1136 | if ( hasBDFAccelerators ) |
| 1137 | { |
| 1138 | error = pcf_get_accel( stream, face, PCF_BDF_ACCELERATORS ); |
| 1139 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1140 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1141 | } |
| 1142 | |
| 1143 | /* XXX: TO DO: inkmetrics and glyph_names are missing */ |
| 1144 | |
| 1145 | /* now construct the face object */ |
| 1146 | { |
| 1147 | FT_Face root = FT_FACE( face ); |
| 1148 | PCF_Property prop; |
| 1149 | |
| 1150 | |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1151 | root->num_faces = 1; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1152 | root->face_index = 0; |
| 1153 | root->face_flags = FT_FACE_FLAG_FIXED_SIZES | |
| 1154 | FT_FACE_FLAG_HORIZONTAL | |
| 1155 | FT_FACE_FLAG_FAST_GLYPHS; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1156 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1157 | if ( face->accel.constantWidth ) |
| 1158 | root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH; |
| 1159 | |
David Turner | 9e185f3 | 2003-12-19 20:25:14 +0000 | [diff] [blame] | 1160 | if ( ( error = pcf_interpret_style( face ) ) != 0 ) |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1161 | goto Exit; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1162 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 1163 | prop = pcf_find_property( face, "FAMILY_NAME" ); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1164 | if ( prop && prop->isString ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1165 | { |
David Turner | c0f9c4a | 2007-02-12 14:55:03 +0000 | [diff] [blame] | 1166 | if ( FT_STRDUP( root->family_name, prop->value.atom ) ) |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1167 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1168 | } |
| 1169 | else |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1170 | root->family_name = NULL; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1171 | |
Werner Lemberg | 9b774e2 | 2007-01-16 06:11:27 +0000 | [diff] [blame] | 1172 | /* |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 1173 | * Note: We shift all glyph indices by +1 since we must |
Werner Lemberg | 428c2e4 | 2003-04-25 05:35:04 +0000 | [diff] [blame] | 1174 | * respect the convention that glyph 0 always corresponds |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 1175 | * to the `missing glyph'. |
Werner Lemberg | 428c2e4 | 2003-04-25 05:35:04 +0000 | [diff] [blame] | 1176 | * |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 1177 | * This implies bumping the number of `available' glyphs by 1. |
Werner Lemberg | 428c2e4 | 2003-04-25 05:35:04 +0000 | [diff] [blame] | 1178 | */ |
David Turner | 2dd1e65 | 2003-04-24 21:12:18 +0000 | [diff] [blame] | 1179 | root->num_glyphs = face->nmetrics + 1; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1180 | |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1181 | root->num_fixed_sizes = 1; |
David Turner | e459d74 | 2002-03-22 13:52:37 +0000 | [diff] [blame] | 1182 | if ( FT_NEW_ARRAY( root->available_sizes, 1 ) ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1183 | goto Exit; |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1184 | |
Werner Lemberg | f891f91 | 2001-12-23 01:38:53 +0000 | [diff] [blame] | 1185 | { |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1186 | FT_Bitmap_Size* bsize = root->available_sizes; |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1187 | FT_Short resolution_x = 0, resolution_y = 0; |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1188 | |
| 1189 | |
| 1190 | FT_MEM_ZERO( bsize, sizeof ( FT_Bitmap_Size ) ); |
| 1191 | |
Wu, Chia-I (吳佳一) | bcc438b | 2006-01-23 14:12:40 +0000 | [diff] [blame] | 1192 | #if 0 |
| 1193 | bsize->height = face->accel.maxbounds.ascent << 6; |
| 1194 | #endif |
Werner Lemberg | 3273a99 | 2004-07-31 23:04:23 +0000 | [diff] [blame] | 1195 | bsize->height = (FT_Short)( face->accel.fontAscent + |
| 1196 | face->accel.fontDescent ); |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1197 | |
| 1198 | prop = pcf_find_property( face, "AVERAGE_WIDTH" ); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1199 | if ( prop ) |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1200 | bsize->width = (FT_Short)( ( prop->value.integer + 5 ) / 10 ); |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1201 | else |
David Turner | 750fa96 | 2005-05-01 10:11:32 +0000 | [diff] [blame] | 1202 | bsize->width = (FT_Short)( bsize->height * 2/3 ); |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1203 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 1204 | prop = pcf_find_property( face, "POINT_SIZE" ); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1205 | if ( prop ) |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1206 | /* convert from 722.7 decipoints to 72 points per inch */ |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1207 | bsize->size = |
| 1208 | (FT_Pos)( ( prop->value.integer * 64 * 7200 + 36135L ) / 72270L ); |
Werner Lemberg | f891f91 | 2001-12-23 01:38:53 +0000 | [diff] [blame] | 1209 | |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1210 | prop = pcf_find_property( face, "PIXEL_SIZE" ); |
| 1211 | if ( prop ) |
| 1212 | bsize->y_ppem = (FT_Short)prop->value.integer << 6; |
| 1213 | |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1214 | prop = pcf_find_property( face, "RESOLUTION_X" ); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1215 | if ( prop ) |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1216 | resolution_x = (FT_Short)prop->value.integer; |
Werner Lemberg | f891f91 | 2001-12-23 01:38:53 +0000 | [diff] [blame] | 1217 | |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1218 | prop = pcf_find_property( face, "RESOLUTION_Y" ); |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1219 | if ( prop ) |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1220 | resolution_y = (FT_Short)prop->value.integer; |
Werner Lemberg | 6d79899 | 2003-07-01 07:28:55 +0000 | [diff] [blame] | 1221 | |
Werner Lemberg | e0c5044 | 2004-02-08 16:30:37 +0000 | [diff] [blame] | 1222 | if ( bsize->y_ppem == 0 ) |
| 1223 | { |
| 1224 | bsize->y_ppem = bsize->size; |
| 1225 | if ( resolution_y ) |
| 1226 | bsize->y_ppem = bsize->y_ppem * resolution_y / 72; |
| 1227 | } |
| 1228 | if ( resolution_x && resolution_y ) |
| 1229 | bsize->x_ppem = bsize->y_ppem * resolution_x / resolution_y; |
| 1230 | else |
| 1231 | bsize->x_ppem = bsize->y_ppem; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1232 | } |
Werner Lemberg | f891f91 | 2001-12-23 01:38:53 +0000 | [diff] [blame] | 1233 | |
Werner Lemberg | 779afe4 | 2003-06-22 15:33:53 +0000 | [diff] [blame] | 1234 | /* set up charset */ |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1235 | { |
| 1236 | PCF_Property charset_registry = 0, charset_encoding = 0; |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 1237 | |
| 1238 | |
David Turner | 0489328 | 2002-02-06 11:22:56 +0000 | [diff] [blame] | 1239 | charset_registry = pcf_find_property( face, "CHARSET_REGISTRY" ); |
| 1240 | charset_encoding = pcf_find_property( face, "CHARSET_ENCODING" ); |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 1241 | |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1242 | if ( charset_registry && charset_registry->isString && |
| 1243 | charset_encoding && charset_encoding->isString ) |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1244 | { |
Werner Lemberg | 442bfb8 | 2007-02-12 21:44:10 +0000 | [diff] [blame^] | 1245 | if ( FT_STRDUP( face->charset_encoding, |
| 1246 | charset_encoding->value.atom ) || |
| 1247 | FT_STRDUP( face->charset_registry, |
| 1248 | charset_registry->value.atom ) ) |
Werner Lemberg | 51ecb69 | 2003-11-13 10:19:27 +0000 | [diff] [blame] | 1249 | goto Exit; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1250 | } |
| 1251 | } |
Werner Lemberg | 93616ec | 2001-06-27 19:46:12 +0000 | [diff] [blame] | 1252 | } |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 1253 | |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1254 | Exit: |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 1255 | if ( error ) |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1256 | { |
Werner Lemberg | 4af3c4d | 2006-07-08 21:31:24 +0000 | [diff] [blame] | 1257 | /* This is done to respect the behaviour of the original */ |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 1258 | /* PCF font driver. */ |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1259 | error = PCF_Err_Invalid_File_Format; |
| 1260 | } |
Werner Lemberg | 1987fb2 | 2002-03-31 06:56:56 +0000 | [diff] [blame] | 1261 | |
David Turner | 42372fd | 2002-03-21 15:02:54 +0000 | [diff] [blame] | 1262 | return error; |
Werner Lemberg | f28b7bf | 2001-01-01 17:24:31 +0000 | [diff] [blame] | 1263 | } |
| 1264 | |
| 1265 | |
| 1266 | /* END */ |