| OLD | NEW |
|---|
| (Empty) |
| 1 /***************************************************************************/ | |
| 2 /* */ | |
| 3 /* ttsbit.c */ | |
| 4 /* */ | |
| 5 /* TrueType and OpenType embedded bitmap support (body). */ | |
| 6 /* */ | |
| 7 /* Copyright 2005-2009, 2013 by */ | |
| 8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */ | |
| 9 /* */ | |
| 10 /* Copyright 2013 by Google, Inc. */ | |
| 11 /* Google Author(s): Behdad Esfahbod. */ | |
| 12 /* */ | |
| 13 /* This file is part of the FreeType project, and may only be used, */ | |
| 14 /* modified, and distributed under the terms of the FreeType project */ | |
| 15 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ | |
| 16 /* this file you indicate that you have read the license and */ | |
| 17 /* understand and accept it fully. */ | |
| 18 /* */ | |
| 19 /***************************************************************************/ | |
| 20 | |
| 21 | |
| 22 #include "../../include/ft2build.h" | |
| 23 #include "../../include/freetype/internal/ftdebug.h" | |
| 24 #include "../../include/freetype/internal/ftstream.h" | |
| 25 #include "../../include/freetype/tttags.h" | |
| 26 #include "../../include/freetype/ftbitmap.h" | |
| 27 #include "ttsbit.h" | |
| 28 | |
| 29 #include "sferrors.h" | |
| 30 | |
| 31 #include "pngshim.h" | |
| 32 | |
| 33 | |
| 34 /*************************************************************************/ | |
| 35 /* */ | |
| 36 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ | |
| 37 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ | |
| 38 /* messages during execution. */ | |
| 39 /* */ | |
| 40 #undef FT_COMPONENT | |
| 41 #define FT_COMPONENT trace_ttsbit | |
| 42 | |
| 43 | |
| 44 FT_LOCAL_DEF( FT_Error ) | |
| 45 tt_face_load_eblc( TT_Face face, | |
| 46 FT_Stream stream ) | |
| 47 { | |
| 48 FT_Error error = FT_Err_Ok; | |
| 49 FT_Fixed version; | |
| 50 FT_ULong num_strikes, table_size; | |
| 51 FT_Byte* p; | |
| 52 FT_Byte* p_limit; | |
| 53 FT_UInt count; | |
| 54 | |
| 55 | |
| 56 face->sbit_num_strikes = 0; | |
| 57 | |
| 58 /* this table is optional */ | |
| 59 error = face->goto_table( face, TTAG_CBLC, stream, &table_size ); | |
| 60 if ( error ) | |
| 61 error = face->goto_table( face, TTAG_EBLC, stream, &table_size ); | |
| 62 if ( error ) | |
| 63 error = face->goto_table( face, TTAG_bloc, stream, &table_size ); | |
| 64 if ( error ) | |
| 65 goto Exit; | |
| 66 | |
| 67 if ( table_size < 8 ) | |
| 68 { | |
| 69 FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" )); | |
| 70 error = FT_THROW( Invalid_File_Format ); | |
| 71 goto Exit; | |
| 72 } | |
| 73 | |
| 74 if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) ) | |
| 75 goto Exit; | |
| 76 | |
| 77 face->sbit_table_size = table_size; | |
| 78 | |
| 79 p = face->sbit_table; | |
| 80 p_limit = p + table_size; | |
| 81 | |
| 82 version = FT_NEXT_ULONG( p ); | |
| 83 num_strikes = FT_NEXT_ULONG( p ); | |
| 84 | |
| 85 if ( version != 0x00020000UL || num_strikes >= 0x10000UL ) | |
| 86 { | |
| 87 FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" )); | |
| 88 error = FT_THROW( Invalid_File_Format ); | |
| 89 goto Fail; | |
| 90 } | |
| 91 | |
| 92 /* | |
| 93 * Count the number of strikes available in the table. We are a bit | |
| 94 * paranoid there and don't trust the data. | |
| 95 */ | |
| 96 count = (FT_UInt)num_strikes; | |
| 97 if ( 8 + 48UL * count > table_size ) | |
| 98 count = (FT_UInt)( ( p_limit - p ) / 48 ); | |
| 99 | |
| 100 face->sbit_num_strikes = count; | |
| 101 | |
| 102 FT_TRACE3(( "sbit_num_strikes: %u\n", count )); | |
| 103 Exit: | |
| 104 return error; | |
| 105 | |
| 106 Fail: | |
| 107 FT_FRAME_RELEASE( face->sbit_table ); | |
| 108 face->sbit_table_size = 0; | |
| 109 goto Exit; | |
| 110 } | |
| 111 | |
| 112 | |
| 113 FT_LOCAL_DEF( void ) | |
| 114 tt_face_free_eblc( TT_Face face ) | |
| 115 { | |
| 116 FT_Stream stream = face->root.stream; | |
| 117 | |
| 118 | |
| 119 FT_FRAME_RELEASE( face->sbit_table ); | |
| 120 face->sbit_table_size = 0; | |
| 121 face->sbit_num_strikes = 0; | |
| 122 } | |
| 123 | |
| 124 | |
| 125 FT_LOCAL_DEF( FT_Error ) | |
| 126 tt_face_set_sbit_strike( TT_Face face, | |
| 127 FT_Size_Request req, | |
| 128 FT_ULong* astrike_index ) | |
| 129 { | |
| 130 return FT_Match_Size( (FT_Face)face, req, 0, astrike_index ); | |
| 131 } | |
| 132 | |
| 133 | |
| 134 FT_LOCAL_DEF( FT_Error ) | |
| 135 tt_face_load_strike_metrics( TT_Face face, | |
| 136 FT_ULong strike_index, | |
| 137 FT_Size_Metrics* metrics ) | |
| 138 { | |
| 139 FT_Byte* strike; | |
| 140 | |
| 141 | |
| 142 if ( strike_index >= (FT_ULong)face->sbit_num_strikes ) | |
| 143 return FT_THROW( Invalid_Argument ); | |
| 144 | |
| 145 strike = face->sbit_table + 8 + strike_index * 48; | |
| 146 | |
| 147 metrics->x_ppem = (FT_UShort)strike[44]; | |
| 148 metrics->y_ppem = (FT_UShort)strike[45]; | |
| 149 | |
| 150 metrics->ascender = (FT_Char)strike[16] << 6; /* hori.ascender */ | |
| 151 metrics->descender = (FT_Char)strike[17] << 6; /* hori.descender */ | |
| 152 metrics->height = metrics->ascender - metrics->descender; | |
| 153 | |
| 154 /* XXX: Is this correct? */ | |
| 155 metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB */ | |
| 156 strike[18] + /* max_width */ | |
| 157 (FT_Char)strike[23] /* min_advance_SB */ | |
| 158 ) << 6; | |
| 159 | |
| 160 return FT_Err_Ok; | |
| 161 } | |
| 162 | |
| 163 | |
| 164 typedef struct TT_SBitDecoderRec_ | |
| 165 { | |
| 166 TT_Face face; | |
| 167 FT_Stream stream; | |
| 168 FT_Bitmap* bitmap; | |
| 169 TT_SBit_Metrics metrics; | |
| 170 FT_Bool metrics_loaded; | |
| 171 FT_Bool bitmap_allocated; | |
| 172 FT_Byte bit_depth; | |
| 173 | |
| 174 FT_ULong ebdt_start; | |
| 175 FT_ULong ebdt_size; | |
| 176 | |
| 177 FT_ULong strike_index_array; | |
| 178 FT_ULong strike_index_count; | |
| 179 FT_Byte* eblc_base; | |
| 180 FT_Byte* eblc_limit; | |
| 181 | |
| 182 } TT_SBitDecoderRec, *TT_SBitDecoder; | |
| 183 | |
| 184 | |
| 185 static FT_Error | |
| 186 tt_sbit_decoder_init( TT_SBitDecoder decoder, | |
| 187 TT_Face face, | |
| 188 FT_ULong strike_index, | |
| 189 TT_SBit_MetricsRec* metrics ) | |
| 190 { | |
| 191 FT_Error error; | |
| 192 FT_Stream stream = face->root.stream; | |
| 193 FT_ULong ebdt_size; | |
| 194 | |
| 195 | |
| 196 error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size ); | |
| 197 if ( error ) | |
| 198 error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size ); | |
| 199 if ( error ) | |
| 200 error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size ); | |
| 201 if ( error ) | |
| 202 goto Exit; | |
| 203 | |
| 204 decoder->face = face; | |
| 205 decoder->stream = stream; | |
| 206 decoder->bitmap = &face->root.glyph->bitmap; | |
| 207 decoder->metrics = metrics; | |
| 208 | |
| 209 decoder->metrics_loaded = 0; | |
| 210 decoder->bitmap_allocated = 0; | |
| 211 | |
| 212 decoder->ebdt_start = FT_STREAM_POS(); | |
| 213 decoder->ebdt_size = ebdt_size; | |
| 214 | |
| 215 decoder->eblc_base = face->sbit_table; | |
| 216 decoder->eblc_limit = face->sbit_table + face->sbit_table_size; | |
| 217 | |
| 218 /* now find the strike corresponding to the index */ | |
| 219 { | |
| 220 FT_Byte* p; | |
| 221 | |
| 222 | |
| 223 if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size ) | |
| 224 { | |
| 225 error = FT_THROW( Invalid_File_Format ); | |
| 226 goto Exit; | |
| 227 } | |
| 228 | |
| 229 p = decoder->eblc_base + 8 + 48 * strike_index; | |
| 230 | |
| 231 decoder->strike_index_array = FT_NEXT_ULONG( p ); | |
| 232 p += 4; | |
| 233 decoder->strike_index_count = FT_NEXT_ULONG( p ); | |
| 234 p += 34; | |
| 235 decoder->bit_depth = *p; | |
| 236 | |
| 237 if ( decoder->strike_index_array > face->sbit_table_size || | |
| 238 decoder->strike_index_array + 8 * decoder->strike_index_count > | |
| 239 face->sbit_table_size ) | |
| 240 error = FT_THROW( Invalid_File_Format ); | |
| 241 } | |
| 242 | |
| 243 Exit: | |
| 244 return error; | |
| 245 } | |
| 246 | |
| 247 | |
| 248 static void | |
| 249 tt_sbit_decoder_done( TT_SBitDecoder decoder ) | |
| 250 { | |
| 251 FT_UNUSED( decoder ); | |
| 252 } | |
| 253 | |
| 254 | |
| 255 static FT_Error | |
| 256 tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder decoder, | |
| 257 FT_UInt load_flags ) | |
| 258 { | |
| 259 FT_Error error = FT_Err_Ok; | |
| 260 FT_UInt width, height; | |
| 261 FT_Bitmap* map = decoder->bitmap; | |
| 262 FT_Long size; | |
| 263 | |
| 264 | |
| 265 if ( !decoder->metrics_loaded ) | |
| 266 { | |
| 267 error = FT_THROW( Invalid_Argument ); | |
| 268 goto Exit; | |
| 269 } | |
| 270 | |
| 271 width = decoder->metrics->width; | |
| 272 height = decoder->metrics->height; | |
| 273 | |
| 274 map->width = (int)width; | |
| 275 map->rows = (int)height; | |
| 276 | |
| 277 switch ( decoder->bit_depth ) | |
| 278 { | |
| 279 case 1: | |
| 280 map->pixel_mode = FT_PIXEL_MODE_MONO; | |
| 281 map->pitch = ( map->width + 7 ) >> 3; | |
| 282 map->num_grays = 2; | |
| 283 break; | |
| 284 | |
| 285 case 2: | |
| 286 map->pixel_mode = FT_PIXEL_MODE_GRAY2; | |
| 287 map->pitch = ( map->width + 3 ) >> 2; | |
| 288 map->num_grays = 4; | |
| 289 break; | |
| 290 | |
| 291 case 4: | |
| 292 map->pixel_mode = FT_PIXEL_MODE_GRAY4; | |
| 293 map->pitch = ( map->width + 1 ) >> 1; | |
| 294 map->num_grays = 16; | |
| 295 break; | |
| 296 | |
| 297 case 8: | |
| 298 map->pixel_mode = FT_PIXEL_MODE_GRAY; | |
| 299 map->pitch = map->width; | |
| 300 map->num_grays = 256; | |
| 301 break; | |
| 302 | |
| 303 case 32: | |
| 304 if ( load_flags & FT_LOAD_COLOR ) | |
| 305 { | |
| 306 map->pixel_mode = FT_PIXEL_MODE_BGRA; | |
| 307 map->pitch = map->width * 4; | |
| 308 map->num_grays = 256; | |
| 309 } | |
| 310 else | |
| 311 { | |
| 312 map->pixel_mode = FT_PIXEL_MODE_GRAY; | |
| 313 map->pitch = map->width; | |
| 314 map->num_grays = 256; | |
| 315 } | |
| 316 break; | |
| 317 | |
| 318 default: | |
| 319 error = FT_THROW( Invalid_File_Format ); | |
| 320 goto Exit; | |
| 321 } | |
| 322 | |
| 323 size = map->rows * map->pitch; | |
| 324 | |
| 325 /* check that there is no empty image */ | |
| 326 if ( size == 0 ) | |
| 327 goto Exit; /* exit successfully! */ | |
| 328 | |
| 329 error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size ); | |
| 330 if ( error ) | |
| 331 goto Exit; | |
| 332 | |
| 333 decoder->bitmap_allocated = 1; | |
| 334 | |
| 335 Exit: | |
| 336 return error; | |
| 337 } | |
| 338 | |
| 339 | |
| 340 static FT_Error | |
| 341 tt_sbit_decoder_load_metrics( TT_SBitDecoder decoder, | |
| 342 FT_Byte* *pp, | |
| 343 FT_Byte* limit, | |
| 344 FT_Bool big ) | |
| 345 { | |
| 346 FT_Byte* p = *pp; | |
| 347 TT_SBit_Metrics metrics = decoder->metrics; | |
| 348 | |
| 349 | |
| 350 if ( p + 5 > limit ) | |
| 351 goto Fail; | |
| 352 | |
| 353 metrics->height = p[0]; | |
| 354 metrics->width = p[1]; | |
| 355 metrics->horiBearingX = (FT_Char)p[2]; | |
| 356 metrics->horiBearingY = (FT_Char)p[3]; | |
| 357 metrics->horiAdvance = p[4]; | |
| 358 | |
| 359 p += 5; | |
| 360 if ( big ) | |
| 361 { | |
| 362 if ( p + 3 > limit ) | |
| 363 goto Fail; | |
| 364 | |
| 365 metrics->vertBearingX = (FT_Char)p[0]; | |
| 366 metrics->vertBearingY = (FT_Char)p[1]; | |
| 367 metrics->vertAdvance = p[2]; | |
| 368 | |
| 369 p += 3; | |
| 370 } | |
| 371 | |
| 372 decoder->metrics_loaded = 1; | |
| 373 *pp = p; | |
| 374 return FT_Err_Ok; | |
| 375 | |
| 376 Fail: | |
| 377 FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table" )); | |
| 378 return FT_THROW( Invalid_Argument ); | |
| 379 } | |
| 380 | |
| 381 | |
| 382 /* forward declaration */ | |
| 383 static FT_Error | |
| 384 tt_sbit_decoder_load_image( TT_SBitDecoder decoder, | |
| 385 FT_UInt load_flags, | |
| 386 FT_UInt glyph_index, | |
| 387 FT_Int x_pos, | |
| 388 FT_Int y_pos ); | |
| 389 | |
| 390 typedef FT_Error (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder decoder, | |
| 391 FT_UInt load_flags, | |
| 392 FT_Byte* p, | |
| 393 FT_Byte* plimit, | |
| 394 FT_Int x_pos, | |
| 395 FT_Int y_pos ); | |
| 396 | |
| 397 | |
| 398 static FT_Error | |
| 399 tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder decoder, | |
| 400 FT_UInt load_flags, | |
| 401 FT_Byte* p, | |
| 402 FT_Byte* limit, | |
| 403 FT_Int x_pos, | |
| 404 FT_Int y_pos ) | |
| 405 { | |
| 406 FT_Error error = FT_Err_Ok; | |
| 407 FT_Byte* line; | |
| 408 FT_Int bit_height, bit_width, pitch, width, height, line_bits, h; | |
| 409 FT_Bitmap* bitmap; | |
| 410 | |
| 411 FT_UNUSED( load_flags ); | |
| 412 | |
| 413 | |
| 414 /* check that we can write the glyph into the bitmap */ | |
| 415 bitmap = decoder->bitmap; | |
| 416 bit_width = bitmap->width; | |
| 417 bit_height = bitmap->rows; | |
| 418 pitch = bitmap->pitch; | |
| 419 line = bitmap->buffer; | |
| 420 | |
| 421 width = decoder->metrics->width; | |
| 422 height = decoder->metrics->height; | |
| 423 | |
| 424 line_bits = width * decoder->bit_depth; | |
| 425 | |
| 426 if ( x_pos < 0 || x_pos + width > bit_width || | |
| 427 y_pos < 0 || y_pos + height > bit_height ) | |
| 428 { | |
| 429 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:" | |
| 430 " invalid bitmap dimensions\n" )); | |
| 431 error = FT_THROW( Invalid_File_Format ); | |
| 432 goto Exit; | |
| 433 } | |
| 434 | |
| 435 if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit ) | |
| 436 { | |
| 437 FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" )); | |
| 438 error = FT_THROW( Invalid_File_Format ); | |
| 439 goto Exit; | |
| 440 } | |
| 441 | |
| 442 /* now do the blit */ | |
| 443 line += y_pos * pitch + ( x_pos >> 3 ); | |
| 444 x_pos &= 7; | |
| 445 | |
| 446 if ( x_pos == 0 ) /* the easy one */ | |
| 447 { | |
| 448 for ( h = height; h > 0; h--, line += pitch ) | |
| 449 { | |
| 450 FT_Byte* pwrite = line; | |
| 451 FT_Int w; | |
| 452 | |
| 453 | |
| 454 for ( w = line_bits; w >= 8; w -= 8 ) | |
| 455 { | |
| 456 pwrite[0] = (FT_Byte)( pwrite[0] | *p++ ); | |
| 457 pwrite += 1; | |
| 458 } | |
| 459 | |
| 460 if ( w > 0 ) | |
| 461 pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) ); | |
| 462 } | |
| 463 } | |
| 464 else /* x_pos > 0 */ | |
| 465 { | |
| 466 for ( h = height; h > 0; h--, line += pitch ) | |
| 467 { | |
| 468 FT_Byte* pwrite = line; | |
| 469 FT_Int w; | |
| 470 FT_UInt wval = 0; | |
| 471 | |
| 472 | |
| 473 for ( w = line_bits; w >= 8; w -= 8 ) | |
| 474 { | |
| 475 wval = (FT_UInt)( wval | *p++ ); | |
| 476 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); | |
| 477 pwrite += 1; | |
| 478 wval <<= 8; | |
| 479 } | |
| 480 | |
| 481 if ( w > 0 ) | |
| 482 wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) ); | |
| 483 | |
| 484 /* all bits read and there are `x_pos + w' bits to be written */ | |
| 485 | |
| 486 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); | |
| 487 | |
| 488 if ( x_pos + w > 8 ) | |
| 489 { | |
| 490 pwrite++; | |
| 491 wval <<= 8; | |
| 492 pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) ); | |
| 493 } | |
| 494 } | |
| 495 } | |
| 496 | |
| 497 Exit: | |
| 498 if ( !error ) | |
| 499 FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" )); | |
| 500 return error; | |
| 501 } | |
| 502 | |
| 503 | |
| 504 /* | |
| 505 * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap | |
| 506 * (with pointer `pwrite'). In the example below, the width is 3 pixel, | |
| 507 * and `x_pos' is 1 pixel. | |
| 508 * | |
| 509 * p p+1 | |
| 510 * | | | | |
| 511 * | 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |... | |
| 512 * | | | | |
| 513 * +-------+ +-------+ +-------+ ... | |
| 514 * . . . | |
| 515 * . . . | |
| 516 * v . . | |
| 517 * +-------+ . . | |
| 518 * | | . | |
| 519 * | 7 6 5 4 3 2 1 0 | . | |
| 520 * | | . | |
| 521 * pwrite . . | |
| 522 * . . | |
| 523 * v . | |
| 524 * +-------+ . | |
| 525 * | | | |
| 526 * | 7 6 5 4 3 2 1 0 | | |
| 527 * | | | |
| 528 * pwrite+1 . | |
| 529 * . | |
| 530 * v | |
| 531 * +-------+ | |
| 532 * | | | |
| 533 * | 7 6 5 4 3 2 1 0 | | |
| 534 * | | | |
| 535 * pwrite+2 | |
| 536 * | |
| 537 */ | |
| 538 | |
| 539 static FT_Error | |
| 540 tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder decoder, | |
| 541 FT_UInt load_flags, | |
| 542 FT_Byte* p, | |
| 543 FT_Byte* limit, | |
| 544 FT_Int x_pos, | |
| 545 FT_Int y_pos ) | |
| 546 { | |
| 547 FT_Error error = FT_Err_Ok; | |
| 548 FT_Byte* line; | |
| 549 FT_Int bit_height, bit_width, pitch, width, height, line_bits, h, nbits
; | |
| 550 FT_Bitmap* bitmap; | |
| 551 FT_UShort rval; | |
| 552 | |
| 553 FT_UNUSED( load_flags ); | |
| 554 | |
| 555 | |
| 556 /* check that we can write the glyph into the bitmap */ | |
| 557 bitmap = decoder->bitmap; | |
| 558 bit_width = bitmap->width; | |
| 559 bit_height = bitmap->rows; | |
| 560 pitch = bitmap->pitch; | |
| 561 line = bitmap->buffer; | |
| 562 | |
| 563 width = decoder->metrics->width; | |
| 564 height = decoder->metrics->height; | |
| 565 | |
| 566 line_bits = width * decoder->bit_depth; | |
| 567 | |
| 568 if ( x_pos < 0 || x_pos + width > bit_width || | |
| 569 y_pos < 0 || y_pos + height > bit_height ) | |
| 570 { | |
| 571 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:" | |
| 572 " invalid bitmap dimensions\n" )); | |
| 573 error = FT_THROW( Invalid_File_Format ); | |
| 574 goto Exit; | |
| 575 } | |
| 576 | |
| 577 if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit ) | |
| 578 { | |
| 579 FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" )); | |
| 580 error = FT_THROW( Invalid_File_Format ); | |
| 581 goto Exit; | |
| 582 } | |
| 583 | |
| 584 /* now do the blit */ | |
| 585 | |
| 586 /* adjust `line' to point to the first byte of the bitmap */ | |
| 587 line += y_pos * pitch + ( x_pos >> 3 ); | |
| 588 x_pos &= 7; | |
| 589 | |
| 590 /* the higher byte of `rval' is used as a buffer */ | |
| 591 rval = 0; | |
| 592 nbits = 0; | |
| 593 | |
| 594 for ( h = height; h > 0; h--, line += pitch ) | |
| 595 { | |
| 596 FT_Byte* pwrite = line; | |
| 597 FT_Int w = line_bits; | |
| 598 | |
| 599 | |
| 600 /* handle initial byte (in target bitmap) specially if necessary */ | |
| 601 if ( x_pos ) | |
| 602 { | |
| 603 w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos; | |
| 604 | |
| 605 if ( h == height ) | |
| 606 { | |
| 607 rval = *p++; | |
| 608 nbits = x_pos; | |
| 609 } | |
| 610 else if ( nbits < w ) | |
| 611 { | |
| 612 if ( p < limit ) | |
| 613 rval |= *p++; | |
| 614 nbits += 8 - w; | |
| 615 } | |
| 616 else | |
| 617 { | |
| 618 rval >>= 8; | |
| 619 nbits -= w; | |
| 620 } | |
| 621 | |
| 622 *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) & | |
| 623 ( ~( 0xFF << w ) << ( 8 - w - x_pos ) ); | |
| 624 rval <<= 8; | |
| 625 | |
| 626 w = line_bits - w; | |
| 627 } | |
| 628 | |
| 629 /* handle medial bytes */ | |
| 630 for ( ; w >= 8; w -= 8 ) | |
| 631 { | |
| 632 rval |= *p++; | |
| 633 *pwrite++ |= ( rval >> nbits ) & 0xFF; | |
| 634 | |
| 635 rval <<= 8; | |
| 636 } | |
| 637 | |
| 638 /* handle final byte if necessary */ | |
| 639 if ( w > 0 ) | |
| 640 { | |
| 641 if ( nbits < w ) | |
| 642 { | |
| 643 if ( p < limit ) | |
| 644 rval |= *p++; | |
| 645 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); | |
| 646 nbits += 8 - w; | |
| 647 | |
| 648 rval <<= 8; | |
| 649 } | |
| 650 else | |
| 651 { | |
| 652 *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w ); | |
| 653 nbits -= w; | |
| 654 } | |
| 655 } | |
| 656 } | |
| 657 | |
| 658 Exit: | |
| 659 if ( !error ) | |
| 660 FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" )); | |
| 661 return error; | |
| 662 } | |
| 663 | |
| 664 | |
| 665 static FT_Error | |
| 666 tt_sbit_decoder_load_compound( TT_SBitDecoder decoder, | |
| 667 FT_UInt load_flags, | |
| 668 FT_Byte* p, | |
| 669 FT_Byte* limit, | |
| 670 FT_Int x_pos, | |
| 671 FT_Int y_pos ) | |
| 672 { | |
| 673 FT_Error error = FT_Err_Ok; | |
| 674 FT_UInt num_components, nn; | |
| 675 | |
| 676 FT_Char horiBearingX = decoder->metrics->horiBearingX; | |
| 677 FT_Char horiBearingY = decoder->metrics->horiBearingY; | |
| 678 FT_Byte horiAdvance = decoder->metrics->horiAdvance; | |
| 679 FT_Char vertBearingX = decoder->metrics->vertBearingX; | |
| 680 FT_Char vertBearingY = decoder->metrics->vertBearingY; | |
| 681 FT_Byte vertAdvance = decoder->metrics->vertAdvance; | |
| 682 | |
| 683 | |
| 684 if ( p + 2 > limit ) | |
| 685 goto Fail; | |
| 686 | |
| 687 num_components = FT_NEXT_USHORT( p ); | |
| 688 if ( p + 4 * num_components > limit ) | |
| 689 { | |
| 690 FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" )); | |
| 691 goto Fail; | |
| 692 } | |
| 693 | |
| 694 FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d components\n", | |
| 695 num_components )); | |
| 696 | |
| 697 for ( nn = 0; nn < num_components; nn++ ) | |
| 698 { | |
| 699 FT_UInt gindex = FT_NEXT_USHORT( p ); | |
| 700 FT_Byte dx = FT_NEXT_BYTE( p ); | |
| 701 FT_Byte dy = FT_NEXT_BYTE( p ); | |
| 702 | |
| 703 | |
| 704 /* NB: a recursive call */ | |
| 705 error = tt_sbit_decoder_load_image( decoder, load_flags, gindex, | |
| 706 x_pos + dx, y_pos + dy ); | |
| 707 if ( error ) | |
| 708 break; | |
| 709 } | |
| 710 | |
| 711 FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" )); | |
| 712 | |
| 713 decoder->metrics->horiBearingX = horiBearingX; | |
| 714 decoder->metrics->horiBearingY = horiBearingY; | |
| 715 decoder->metrics->horiAdvance = horiAdvance; | |
| 716 decoder->metrics->vertBearingX = vertBearingX; | |
| 717 decoder->metrics->vertBearingY = vertBearingY; | |
| 718 decoder->metrics->vertAdvance = vertAdvance; | |
| 719 decoder->metrics->width = (FT_Byte)decoder->bitmap->width; | |
| 720 decoder->metrics->height = (FT_Byte)decoder->bitmap->rows; | |
| 721 | |
| 722 Exit: | |
| 723 return error; | |
| 724 | |
| 725 Fail: | |
| 726 error = FT_THROW( Invalid_File_Format ); | |
| 727 goto Exit; | |
| 728 } | |
| 729 | |
| 730 | |
| 731 #ifdef FT_CONFIG_OPTION_USE_PNG | |
| 732 | |
| 733 static FT_Error | |
| 734 tt_sbit_decoder_load_png( TT_SBitDecoder decoder, | |
| 735 FT_UInt load_flags, | |
| 736 FT_Byte* p, | |
| 737 FT_Byte* limit, | |
| 738 FT_Int x_pos, | |
| 739 FT_Int y_pos ) | |
| 740 { | |
| 741 FT_Error error = FT_Err_Ok; | |
| 742 FT_ULong png_len; | |
| 743 | |
| 744 FT_UNUSED( load_flags ); | |
| 745 | |
| 746 | |
| 747 if ( limit - p < 4 ) | |
| 748 { | |
| 749 FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); | |
| 750 error = FT_THROW( Invalid_File_Format ); | |
| 751 goto Exit; | |
| 752 } | |
| 753 | |
| 754 png_len = FT_NEXT_ULONG( p ); | |
| 755 if ( (FT_ULong)( limit - p ) < png_len ) | |
| 756 { | |
| 757 FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" )); | |
| 758 error = FT_THROW( Invalid_File_Format ); | |
| 759 goto Exit; | |
| 760 } | |
| 761 | |
| 762 error = Load_SBit_Png( decoder->bitmap, | |
| 763 x_pos, | |
| 764 y_pos, | |
| 765 decoder->bit_depth, | |
| 766 decoder->metrics, | |
| 767 decoder->stream->memory, | |
| 768 p, | |
| 769 png_len ); | |
| 770 | |
| 771 Exit: | |
| 772 if ( !error ) | |
| 773 FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" )); | |
| 774 return error; | |
| 775 } | |
| 776 | |
| 777 #endif /* FT_CONFIG_OPTION_USE_PNG */ | |
| 778 | |
| 779 | |
| 780 static FT_Error | |
| 781 tt_sbit_decoder_load_bitmap( TT_SBitDecoder decoder, | |
| 782 FT_UInt load_flags, | |
| 783 FT_UInt glyph_format, | |
| 784 FT_ULong glyph_start, | |
| 785 FT_ULong glyph_size, | |
| 786 FT_Int x_pos, | |
| 787 FT_Int y_pos ) | |
| 788 { | |
| 789 FT_Error error; | |
| 790 FT_Stream stream = decoder->stream; | |
| 791 FT_Byte* p; | |
| 792 FT_Byte* p_limit; | |
| 793 FT_Byte* data; | |
| 794 | |
| 795 | |
| 796 /* seek into the EBDT table now */ | |
| 797 if ( glyph_start + glyph_size > decoder->ebdt_size ) | |
| 798 { | |
| 799 error = FT_THROW( Invalid_Argument ); | |
| 800 goto Exit; | |
| 801 } | |
| 802 | |
| 803 if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) || | |
| 804 FT_FRAME_EXTRACT( glyph_size, data ) ) | |
| 805 goto Exit; | |
| 806 | |
| 807 p = data; | |
| 808 p_limit = p + glyph_size; | |
| 809 | |
| 810 /* read the data, depending on the glyph format */ | |
| 811 switch ( glyph_format ) | |
| 812 { | |
| 813 case 1: | |
| 814 case 2: | |
| 815 case 8: | |
| 816 case 17: | |
| 817 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 ); | |
| 818 break; | |
| 819 | |
| 820 case 6: | |
| 821 case 7: | |
| 822 case 9: | |
| 823 case 18: | |
| 824 error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ); | |
| 825 break; | |
| 826 | |
| 827 default: | |
| 828 error = FT_Err_Ok; | |
| 829 } | |
| 830 | |
| 831 if ( error ) | |
| 832 goto Fail; | |
| 833 | |
| 834 { | |
| 835 TT_SBitDecoder_LoadFunc loader; | |
| 836 | |
| 837 | |
| 838 switch ( glyph_format ) | |
| 839 { | |
| 840 case 1: | |
| 841 case 6: | |
| 842 loader = tt_sbit_decoder_load_byte_aligned; | |
| 843 break; | |
| 844 | |
| 845 case 2: | |
| 846 case 5: | |
| 847 case 7: | |
| 848 loader = tt_sbit_decoder_load_bit_aligned; | |
| 849 break; | |
| 850 | |
| 851 case 8: | |
| 852 if ( p + 1 > p_limit ) | |
| 853 goto Fail; | |
| 854 | |
| 855 p += 1; /* skip padding */ | |
| 856 /* fall-through */ | |
| 857 | |
| 858 case 9: | |
| 859 loader = tt_sbit_decoder_load_compound; | |
| 860 break; | |
| 861 | |
| 862 #ifdef FT_CONFIG_OPTION_USE_PNG | |
| 863 case 17: /* small metrics, PNG image data */ | |
| 864 case 18: /* big metrics, PNG image data */ | |
| 865 case 19: /* metrics in EBLC, PNG image data */ | |
| 866 loader = tt_sbit_decoder_load_png; | |
| 867 break; | |
| 868 #endif /* FT_CONFIG_OPTION_USE_PNG */ | |
| 869 | |
| 870 default: | |
| 871 error = FT_THROW( Invalid_Table ); | |
| 872 goto Fail; | |
| 873 } | |
| 874 | |
| 875 if ( !decoder->bitmap_allocated ) | |
| 876 { | |
| 877 error = tt_sbit_decoder_alloc_bitmap( decoder, load_flags ); | |
| 878 if ( error ) | |
| 879 goto Fail; | |
| 880 } | |
| 881 | |
| 882 if ( decoder->bit_depth == 32 && | |
| 883 decoder->bitmap->pixel_mode != FT_PIXEL_MODE_BGRA ) | |
| 884 { | |
| 885 /* Flatten color bitmaps if color was not requested. */ | |
| 886 | |
| 887 FT_Library library = decoder->face->root.glyph->library; | |
| 888 FT_Memory memory = decoder->stream->memory; | |
| 889 | |
| 890 FT_Bitmap color, *orig; | |
| 891 | |
| 892 | |
| 893 if ( decoder->bitmap->pixel_mode != FT_PIXEL_MODE_GRAY || | |
| 894 x_pos != 0 || y_pos != 0 ) | |
| 895 { | |
| 896 /* Shouldn't happen. */ | |
| 897 error = FT_THROW( Invalid_Table ); | |
| 898 goto Fail; | |
| 899 } | |
| 900 | |
| 901 FT_Bitmap_New( &color ); | |
| 902 | |
| 903 color.rows = decoder->bitmap->rows; | |
| 904 color.width = decoder->bitmap->width; | |
| 905 color.pitch = color.width * 4; | |
| 906 color.pixel_mode = FT_PIXEL_MODE_BGRA; | |
| 907 | |
| 908 if ( FT_ALLOC( color.buffer, color.rows * color.pitch ) ) | |
| 909 goto Fail; | |
| 910 | |
| 911 orig = decoder->bitmap; | |
| 912 decoder->bitmap = &color; | |
| 913 | |
| 914 error = loader( decoder, load_flags, p, p_limit, x_pos, y_pos ); | |
| 915 | |
| 916 decoder->bitmap = orig; | |
| 917 | |
| 918 /* explicitly test against FT_Err_Ok to avoid compiler warnings */ | |
| 919 /* (we do an assignment within a conditional) */ | |
| 920 if ( error || | |
| 921 ( error = FT_Bitmap_Convert( library, | |
| 922 &color, | |
| 923 decoder->bitmap, | |
| 924 1 ) ) != FT_Err_Ok ) | |
| 925 { | |
| 926 FT_Bitmap_Done( library, &color ); | |
| 927 goto Fail; | |
| 928 } | |
| 929 | |
| 930 FT_Bitmap_Done( library, &color ); | |
| 931 } | |
| 932 | |
| 933 else | |
| 934 error = loader( decoder, load_flags, p, p_limit, x_pos, y_pos ); | |
| 935 } | |
| 936 | |
| 937 Fail: | |
| 938 FT_FRAME_RELEASE( data ); | |
| 939 | |
| 940 Exit: | |
| 941 return error; | |
| 942 } | |
| 943 | |
| 944 | |
| 945 static FT_Error | |
| 946 tt_sbit_decoder_load_image( TT_SBitDecoder decoder, | |
| 947 FT_UInt load_flags, | |
| 948 FT_UInt glyph_index, | |
| 949 FT_Int x_pos, | |
| 950 FT_Int y_pos ) | |
| 951 { | |
| 952 /* | |
| 953 * First, we find the correct strike range that applies to this | |
| 954 * glyph index. | |
| 955 */ | |
| 956 | |
| 957 FT_Byte* p = decoder->eblc_base + decoder->strike_index_array; | |
| 958 FT_Byte* p_limit = decoder->eblc_limit; | |
| 959 FT_ULong num_ranges = decoder->strike_index_count; | |
| 960 FT_UInt start, end, index_format, image_format; | |
| 961 FT_ULong image_start = 0, image_end = 0, image_offset; | |
| 962 | |
| 963 | |
| 964 for ( ; num_ranges > 0; num_ranges-- ) | |
| 965 { | |
| 966 start = FT_NEXT_USHORT( p ); | |
| 967 end = FT_NEXT_USHORT( p ); | |
| 968 | |
| 969 if ( glyph_index >= start && glyph_index <= end ) | |
| 970 goto FoundRange; | |
| 971 | |
| 972 p += 4; /* ignore index offset */ | |
| 973 } | |
| 974 goto NoBitmap; | |
| 975 | |
| 976 FoundRange: | |
| 977 image_offset = FT_NEXT_ULONG( p ); | |
| 978 | |
| 979 /* overflow check */ | |
| 980 p = decoder->eblc_base + decoder->strike_index_array; | |
| 981 if ( image_offset > (FT_ULong)( p_limit - p ) ) | |
| 982 goto Failure; | |
| 983 | |
| 984 p += image_offset; | |
| 985 if ( p + 8 > p_limit ) | |
| 986 goto NoBitmap; | |
| 987 | |
| 988 /* now find the glyph's location and extend within the ebdt table */ | |
| 989 index_format = FT_NEXT_USHORT( p ); | |
| 990 image_format = FT_NEXT_USHORT( p ); | |
| 991 image_offset = FT_NEXT_ULONG ( p ); | |
| 992 | |
| 993 switch ( index_format ) | |
| 994 { | |
| 995 case 1: /* 4-byte offsets relative to `image_offset' */ | |
| 996 { | |
| 997 p += 4 * ( glyph_index - start ); | |
| 998 if ( p + 8 > p_limit ) | |
| 999 goto NoBitmap; | |
| 1000 | |
| 1001 image_start = FT_NEXT_ULONG( p ); | |
| 1002 image_end = FT_NEXT_ULONG( p ); | |
| 1003 | |
| 1004 if ( image_start == image_end ) /* missing glyph */ | |
| 1005 goto NoBitmap; | |
| 1006 } | |
| 1007 break; | |
| 1008 | |
| 1009 case 2: /* big metrics, constant image size */ | |
| 1010 { | |
| 1011 FT_ULong image_size; | |
| 1012 | |
| 1013 | |
| 1014 if ( p + 12 > p_limit ) | |
| 1015 goto NoBitmap; | |
| 1016 | |
| 1017 image_size = FT_NEXT_ULONG( p ); | |
| 1018 | |
| 1019 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) | |
| 1020 goto NoBitmap; | |
| 1021 | |
| 1022 image_start = image_size * ( glyph_index - start ); | |
| 1023 image_end = image_start + image_size; | |
| 1024 } | |
| 1025 break; | |
| 1026 | |
| 1027 case 3: /* 2-byte offsets relative to 'image_offset' */ | |
| 1028 { | |
| 1029 p += 2 * ( glyph_index - start ); | |
| 1030 if ( p + 4 > p_limit ) | |
| 1031 goto NoBitmap; | |
| 1032 | |
| 1033 image_start = FT_NEXT_USHORT( p ); | |
| 1034 image_end = FT_NEXT_USHORT( p ); | |
| 1035 | |
| 1036 if ( image_start == image_end ) /* missing glyph */ | |
| 1037 goto NoBitmap; | |
| 1038 } | |
| 1039 break; | |
| 1040 | |
| 1041 case 4: /* sparse glyph array with (glyph,offset) pairs */ | |
| 1042 { | |
| 1043 FT_ULong mm, num_glyphs; | |
| 1044 | |
| 1045 | |
| 1046 if ( p + 4 > p_limit ) | |
| 1047 goto NoBitmap; | |
| 1048 | |
| 1049 num_glyphs = FT_NEXT_ULONG( p ); | |
| 1050 | |
| 1051 /* overflow check for p + ( num_glyphs + 1 ) * 4 */ | |
| 1052 if ( num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) ) | |
| 1053 goto NoBitmap; | |
| 1054 | |
| 1055 for ( mm = 0; mm < num_glyphs; mm++ ) | |
| 1056 { | |
| 1057 FT_UInt gindex = FT_NEXT_USHORT( p ); | |
| 1058 | |
| 1059 | |
| 1060 if ( gindex == glyph_index ) | |
| 1061 { | |
| 1062 image_start = FT_NEXT_USHORT( p ); | |
| 1063 p += 2; | |
| 1064 image_end = FT_PEEK_USHORT( p ); | |
| 1065 break; | |
| 1066 } | |
| 1067 p += 2; | |
| 1068 } | |
| 1069 | |
| 1070 if ( mm >= num_glyphs ) | |
| 1071 goto NoBitmap; | |
| 1072 } | |
| 1073 break; | |
| 1074 | |
| 1075 case 5: /* constant metrics with sparse glyph codes */ | |
| 1076 case 19: | |
| 1077 { | |
| 1078 FT_ULong image_size, mm, num_glyphs; | |
| 1079 | |
| 1080 | |
| 1081 if ( p + 16 > p_limit ) | |
| 1082 goto NoBitmap; | |
| 1083 | |
| 1084 image_size = FT_NEXT_ULONG( p ); | |
| 1085 | |
| 1086 if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) ) | |
| 1087 goto NoBitmap; | |
| 1088 | |
| 1089 num_glyphs = FT_NEXT_ULONG( p ); | |
| 1090 | |
| 1091 /* overflow check for p + 2 * num_glyphs */ | |
| 1092 if ( num_glyphs > (FT_ULong)( ( p_limit - p ) >> 1 ) ) | |
| 1093 goto NoBitmap; | |
| 1094 | |
| 1095 for ( mm = 0; mm < num_glyphs; mm++ ) | |
| 1096 { | |
| 1097 FT_UInt gindex = FT_NEXT_USHORT( p ); | |
| 1098 | |
| 1099 | |
| 1100 if ( gindex == glyph_index ) | |
| 1101 break; | |
| 1102 } | |
| 1103 | |
| 1104 if ( mm >= num_glyphs ) | |
| 1105 goto NoBitmap; | |
| 1106 | |
| 1107 image_start = image_size * mm; | |
| 1108 image_end = image_start + image_size; | |
| 1109 } | |
| 1110 break; | |
| 1111 | |
| 1112 default: | |
| 1113 goto NoBitmap; | |
| 1114 } | |
| 1115 | |
| 1116 if ( image_start > image_end ) | |
| 1117 goto NoBitmap; | |
| 1118 | |
| 1119 image_end -= image_start; | |
| 1120 image_start = image_offset + image_start; | |
| 1121 | |
| 1122 FT_TRACE3(( "tt_sbit_decoder_load_image:" | |
| 1123 " found sbit (format %d) for glyph index %d\n", | |
| 1124 image_format, glyph_index )); | |
| 1125 | |
| 1126 return tt_sbit_decoder_load_bitmap( decoder, | |
| 1127 load_flags, | |
| 1128 image_format, | |
| 1129 image_start, | |
| 1130 image_end, | |
| 1131 x_pos, | |
| 1132 y_pos ); | |
| 1133 | |
| 1134 Failure: | |
| 1135 return FT_THROW( Invalid_Table ); | |
| 1136 | |
| 1137 NoBitmap: | |
| 1138 FT_TRACE4(( "tt_sbit_decoder_load_image:" | |
| 1139 " no sbit found for glyph index %d\n", glyph_index )); | |
| 1140 | |
| 1141 return FT_THROW( Invalid_Argument ); | |
| 1142 } | |
| 1143 | |
| 1144 | |
| 1145 FT_LOCAL( FT_Error ) | |
| 1146 tt_face_load_sbit_image( TT_Face face, | |
| 1147 FT_ULong strike_index, | |
| 1148 FT_UInt glyph_index, | |
| 1149 FT_UInt load_flags, | |
| 1150 FT_Stream stream, | |
| 1151 FT_Bitmap *map, | |
| 1152 TT_SBit_MetricsRec *metrics ) | |
| 1153 { | |
| 1154 TT_SBitDecoderRec decoder[1]; | |
| 1155 FT_Error error; | |
| 1156 | |
| 1157 FT_UNUSED( load_flags ); | |
| 1158 FT_UNUSED( stream ); | |
| 1159 FT_UNUSED( map ); | |
| 1160 | |
| 1161 | |
| 1162 error = tt_sbit_decoder_init( decoder, face, strike_index, metrics ); | |
| 1163 if ( !error ) | |
| 1164 { | |
| 1165 error = tt_sbit_decoder_load_image( decoder, | |
| 1166 load_flags, | |
| 1167 glyph_index, | |
| 1168 0, | |
| 1169 0 ); | |
| 1170 tt_sbit_decoder_done( decoder ); | |
| 1171 } | |
| 1172 | |
| 1173 return error; | |
| 1174 } | |
| 1175 | |
| 1176 | |
| 1177 /* EOF */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 815103002:
Update freetype to 2.5.4. (Closed)
Base URL: https://pdfium.googlesource.com/pdfium.git@master