pngshim.c (13188B)
1 /**************************************************************************** 2 * 3 * pngshim.c 4 * 5 * PNG Bitmap glyph support. 6 * 7 * Copyright (C) 2013-2025 by 8 * Google, Inc. 9 * Written by Stuart Gill and Behdad Esfahbod. 10 * 11 * This file is part of the FreeType project, and may only be used, 12 * modified, and distributed under the terms of the FreeType project 13 * license, LICENSE.TXT. By continuing to use, modify, or distribute 14 * this file you indicate that you have read the license and 15 * understand and accept it fully. 16 * 17 */ 18 19 20 #include <freetype/internal/ftdebug.h> 21 #include <freetype/internal/ftstream.h> 22 #include <freetype/tttags.h> 23 #include FT_CONFIG_STANDARD_LIBRARY_H 24 25 26 #if defined( TT_CONFIG_OPTION_EMBEDDED_BITMAPS ) && \ 27 defined( FT_CONFIG_OPTION_USE_PNG ) 28 29 /* We always include <setjmp.h>, so make libpng shut up! */ 30 #define PNG_SKIP_SETJMP_CHECK 1 31 #include <png.h> 32 #include "pngshim.h" 33 34 #include "sferrors.h" 35 36 37 /* This code is freely based on cairo-png.c. There's so many ways */ 38 /* to call libpng, and the way cairo does it is defacto standard. */ 39 40 static unsigned int 41 multiply_alpha( unsigned int alpha, 42 unsigned int color ) 43 { 44 unsigned int temp = alpha * color + 0x80; 45 46 47 return ( temp + ( temp >> 8 ) ) >> 8; 48 } 49 50 51 /* Premultiplies data and converts RGBA bytes => BGRA. */ 52 static void 53 premultiply_data( png_structp png, 54 png_row_infop row_info, 55 png_bytep data ) 56 { 57 unsigned int i = 0, limit; 58 59 /* The `vector_size' attribute was introduced in gcc 3.1, which */ 60 /* predates clang; the `__BYTE_ORDER__' preprocessor symbol was */ 61 /* introduced in gcc 4.6 and clang 3.2, respectively. */ 62 /* `__builtin_shuffle' for gcc was introduced in gcc 4.7.0. */ 63 /* */ 64 /* Intel compilers do not currently support __builtin_shuffle; */ 65 66 /* The Intel check must be first. */ 67 #if !defined( __INTEL_COMPILER ) && \ 68 ( ( defined( __GNUC__ ) && \ 69 ( ( __GNUC__ >= 5 ) || \ 70 ( ( __GNUC__ == 4 ) && ( __GNUC_MINOR__ >= 7 ) ) ) ) || \ 71 ( defined( __clang__ ) && \ 72 ( ( __clang_major__ >= 4 ) || \ 73 ( ( __clang_major__ == 3 ) && ( __clang_minor__ >= 2 ) ) ) ) ) && \ 74 defined( __OPTIMIZE__ ) && \ 75 defined( __SSE__ ) && \ 76 __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 77 78 #ifdef __clang__ 79 /* the clang documentation doesn't cover the two-argument case of */ 80 /* `__builtin_shufflevector'; however, it is is implemented since */ 81 /* version 2.8 */ 82 #define vector_shuffle __builtin_shufflevector 83 #else 84 #define vector_shuffle __builtin_shuffle 85 #endif 86 87 typedef unsigned short v82 __attribute__(( vector_size( 16 ) )); 88 89 90 if ( row_info->rowbytes > 15 ) 91 { 92 /* process blocks of 16 bytes in one rush, which gives a nice speed-up */ 93 limit = row_info->rowbytes - 16 + 1; 94 for ( ; i < limit; i += 16 ) 95 { 96 unsigned char* base = &data[i]; 97 98 v82 s, s0, s1, a; 99 100 /* clang <= 3.9 can't apply scalar values to vectors */ 101 /* (or rather, it needs a different syntax) */ 102 v82 n0x80 = { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }; 103 v82 n0xFF = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 104 v82 n8 = { 8, 8, 8, 8, 8, 8, 8, 8 }; 105 106 v82 ma = { 1, 1, 3, 3, 5, 5, 7, 7 }; 107 v82 o1 = { 0, 0xFF, 0, 0xFF, 0, 0xFF, 0, 0xFF }; 108 v82 m0 = { 1, 0, 3, 2, 5, 4, 7, 6 }; 109 110 111 ft_memcpy( &s, base, 16 ); /* RGBA RGBA RGBA RGBA */ 112 s0 = s & n0xFF; /* R B R B R B R B */ 113 s1 = s >> n8; /* G A G A G A G A */ 114 115 a = vector_shuffle( s1, ma ); /* A A A A A A A A */ 116 s1 |= o1; /* G 1 G 1 G 1 G 1 */ 117 s0 = vector_shuffle( s0, m0 ); /* B R B R B R B R */ 118 119 s0 *= a; 120 s1 *= a; 121 s0 += n0x80; 122 s1 += n0x80; 123 s0 = ( s0 + ( s0 >> n8 ) ) >> n8; 124 s1 = ( s1 + ( s1 >> n8 ) ) >> n8; 125 126 s = s0 | ( s1 << n8 ); 127 ft_memcpy( base, &s, 16 ); 128 } 129 } 130 #endif /* use `vector_size' */ 131 132 FT_UNUSED( png ); 133 134 limit = row_info->rowbytes; 135 for ( ; i < limit; i += 4 ) 136 { 137 unsigned char* base = &data[i]; 138 unsigned int alpha = base[3]; 139 140 141 if ( alpha == 0 ) 142 base[0] = base[1] = base[2] = base[3] = 0; 143 144 else 145 { 146 unsigned int red = base[0]; 147 unsigned int green = base[1]; 148 unsigned int blue = base[2]; 149 150 151 if ( alpha != 0xFF ) 152 { 153 red = multiply_alpha( alpha, red ); 154 green = multiply_alpha( alpha, green ); 155 blue = multiply_alpha( alpha, blue ); 156 } 157 158 base[0] = (unsigned char)blue; 159 base[1] = (unsigned char)green; 160 base[2] = (unsigned char)red; 161 base[3] = (unsigned char)alpha; 162 } 163 } 164 } 165 166 167 /* Converts RGBx bytes to BGRA. */ 168 static void 169 convert_bytes_to_data( png_structp png, 170 png_row_infop row_info, 171 png_bytep data ) 172 { 173 unsigned int i; 174 175 FT_UNUSED( png ); 176 177 178 for ( i = 0; i < row_info->rowbytes; i += 4 ) 179 { 180 unsigned char* base = &data[i]; 181 unsigned int red = base[0]; 182 unsigned int green = base[1]; 183 unsigned int blue = base[2]; 184 185 186 base[0] = (unsigned char)blue; 187 base[1] = (unsigned char)green; 188 base[2] = (unsigned char)red; 189 base[3] = 0xFF; 190 } 191 } 192 193 194 /* Use error callback to avoid png writing to stderr. */ 195 static void 196 error_callback( png_structp png, 197 png_const_charp error_msg ) 198 { 199 FT_Error* error = (FT_Error*)png_get_error_ptr( png ); 200 201 FT_UNUSED( error_msg ); 202 203 204 *error = FT_THROW( Out_Of_Memory ); 205 #ifdef PNG_SETJMP_SUPPORTED 206 ft_longjmp( png_jmpbuf( png ), 1 ); 207 #endif 208 /* if we get here, then we have no choice but to abort ... */ 209 } 210 211 212 /* Use warning callback to avoid png writing to stderr. */ 213 static void 214 warning_callback( png_structp png, 215 png_const_charp error_msg ) 216 { 217 FT_UNUSED( png ); 218 FT_UNUSED( error_msg ); 219 220 /* Just ignore warnings. */ 221 } 222 223 224 static void 225 read_data_from_FT_Stream( png_structp png, 226 png_bytep data, 227 png_size_t length ) 228 { 229 FT_Error error; 230 png_voidp p = png_get_io_ptr( png ); 231 FT_Stream stream = (FT_Stream)p; 232 233 234 if ( FT_FRAME_ENTER( length ) ) 235 { 236 FT_Error* e = (FT_Error*)png_get_error_ptr( png ); 237 238 239 *e = FT_THROW( Invalid_Stream_Read ); 240 png_error( png, NULL ); 241 242 /* return; (never reached) */ 243 } 244 245 ft_memcpy( data, stream->cursor, length ); 246 247 FT_FRAME_EXIT(); 248 } 249 250 251 FT_LOCAL_DEF( FT_Error ) 252 Load_SBit_Png( FT_GlyphSlot slot, 253 FT_Int x_offset, 254 FT_Int y_offset, 255 FT_Int pix_bits, 256 TT_SBit_Metrics metrics, 257 FT_Memory memory, 258 FT_Byte* data, 259 FT_UInt png_len, 260 FT_Bool populate_map_and_metrics, 261 FT_Bool metrics_only ) 262 { 263 FT_Bitmap *map = &slot->bitmap; 264 FT_Error error = FT_Err_Ok; 265 FT_StreamRec stream; 266 267 png_structp png; 268 png_infop info; 269 png_uint_32 imgWidth, imgHeight; 270 271 int bitdepth, color_type, interlace; 272 FT_Int i; 273 274 /* `rows` gets modified within a 'setjmp' scope; */ 275 /* we thus need the `volatile` keyword. */ 276 png_byte* *volatile rows = NULL; 277 278 279 if ( x_offset < 0 || 280 y_offset < 0 ) 281 { 282 error = FT_THROW( Invalid_Argument ); 283 goto Exit; 284 } 285 286 if ( !populate_map_and_metrics && 287 ( (FT_UInt)x_offset + metrics->width > map->width || 288 (FT_UInt)y_offset + metrics->height > map->rows || 289 pix_bits != 32 || 290 map->pixel_mode != FT_PIXEL_MODE_BGRA ) ) 291 { 292 error = FT_THROW( Invalid_Argument ); 293 goto Exit; 294 } 295 296 FT_Stream_OpenMemory( &stream, data, png_len ); 297 298 png = png_create_read_struct( PNG_LIBPNG_VER_STRING, 299 &error, 300 error_callback, 301 warning_callback ); 302 if ( !png ) 303 { 304 error = FT_THROW( Out_Of_Memory ); 305 goto Exit; 306 } 307 308 info = png_create_info_struct( png ); 309 if ( !info ) 310 { 311 error = FT_THROW( Out_Of_Memory ); 312 png_destroy_read_struct( &png, NULL, NULL ); 313 goto Exit; 314 } 315 316 if ( ft_setjmp( png_jmpbuf( png ) ) ) 317 { 318 error = FT_THROW( Invalid_File_Format ); 319 goto DestroyExit; 320 } 321 322 png_set_read_fn( png, &stream, read_data_from_FT_Stream ); 323 324 png_read_info( png, info ); 325 png_get_IHDR( png, info, 326 &imgWidth, &imgHeight, 327 &bitdepth, &color_type, &interlace, 328 NULL, NULL ); 329 330 if ( error || 331 ( !populate_map_and_metrics && 332 ( (FT_Int)imgWidth != metrics->width || 333 (FT_Int)imgHeight != metrics->height ) ) ) 334 goto DestroyExit; 335 336 if ( populate_map_and_metrics ) 337 { 338 /* reject too large bitmaps similarly to the rasterizer */ 339 if ( imgHeight > 0x7FFF || imgWidth > 0x7FFF ) 340 { 341 error = FT_THROW( Array_Too_Large ); 342 goto DestroyExit; 343 } 344 345 metrics->width = (FT_UShort)imgWidth; 346 metrics->height = (FT_UShort)imgHeight; 347 348 map->width = metrics->width; 349 map->rows = metrics->height; 350 map->pixel_mode = FT_PIXEL_MODE_BGRA; 351 map->pitch = (int)( map->width * 4 ); 352 map->num_grays = 256; 353 } 354 355 /* convert palette/gray image to rgb */ 356 if ( color_type == PNG_COLOR_TYPE_PALETTE ) 357 png_set_palette_to_rgb( png ); 358 359 /* expand gray bit depth if needed */ 360 if ( color_type == PNG_COLOR_TYPE_GRAY ) 361 { 362 #if PNG_LIBPNG_VER >= 10209 363 png_set_expand_gray_1_2_4_to_8( png ); 364 #else 365 png_set_gray_1_2_4_to_8( png ); 366 #endif 367 } 368 369 /* transform transparency to alpha */ 370 if ( png_get_valid( png, info, PNG_INFO_tRNS ) ) 371 png_set_tRNS_to_alpha( png ); 372 373 if ( bitdepth == 16 ) 374 png_set_strip_16( png ); 375 376 if ( bitdepth < 8 ) 377 png_set_packing( png ); 378 379 /* convert grayscale to RGB */ 380 if ( color_type == PNG_COLOR_TYPE_GRAY || 381 color_type == PNG_COLOR_TYPE_GRAY_ALPHA ) 382 png_set_gray_to_rgb( png ); 383 384 if ( interlace != PNG_INTERLACE_NONE ) 385 png_set_interlace_handling( png ); 386 387 png_set_filler( png, 0xFF, PNG_FILLER_AFTER ); 388 389 /* recheck header after setting EXPAND options */ 390 png_read_update_info( png, info ); 391 png_get_IHDR( png, info, 392 &imgWidth, &imgHeight, 393 &bitdepth, &color_type, &interlace, 394 NULL, NULL ); 395 396 if ( bitdepth != 8 || 397 !( color_type == PNG_COLOR_TYPE_RGB || 398 color_type == PNG_COLOR_TYPE_RGB_ALPHA ) ) 399 { 400 error = FT_THROW( Invalid_File_Format ); 401 goto DestroyExit; 402 } 403 404 if ( metrics_only ) 405 goto DestroyExit; 406 407 switch ( color_type ) 408 { 409 default: /* Shouldn't happen, but ... */ 410 case PNG_COLOR_TYPE_RGB_ALPHA: 411 png_set_read_user_transform_fn( png, premultiply_data ); 412 break; 413 414 case PNG_COLOR_TYPE_RGB: 415 /* Humm, this smells. Carry on though. */ 416 png_set_read_user_transform_fn( png, convert_bytes_to_data ); 417 break; 418 } 419 420 if ( populate_map_and_metrics ) 421 { 422 /* this doesn't overflow: 0x7FFF * 0x7FFF * 4 < 2^32 */ 423 FT_ULong size = map->rows * (FT_ULong)map->pitch; 424 425 426 error = ft_glyphslot_alloc_bitmap( slot, size ); 427 if ( error ) 428 goto DestroyExit; 429 } 430 431 if ( FT_QNEW_ARRAY( rows, imgHeight ) ) 432 { 433 error = FT_THROW( Out_Of_Memory ); 434 goto DestroyExit; 435 } 436 437 for ( i = 0; i < (FT_Int)imgHeight; i++ ) 438 rows[i] = map->buffer + ( y_offset + i ) * map->pitch + x_offset * 4; 439 440 png_read_image( png, rows ); 441 442 png_read_end( png, info ); 443 444 DestroyExit: 445 /* even if reading fails with longjmp, rows must be freed */ 446 FT_FREE( rows ); 447 png_destroy_read_struct( &png, &info, NULL ); 448 FT_Stream_Close( &stream ); 449 450 Exit: 451 return error; 452 } 453 454 #else /* !(TT_CONFIG_OPTION_EMBEDDED_BITMAPS && FT_CONFIG_OPTION_USE_PNG) */ 455 456 /* ANSI C doesn't like empty source files */ 457 typedef int pngshim_dummy_; 458 459 #endif /* !(TT_CONFIG_OPTION_EMBEDDED_BITMAPS && FT_CONFIG_OPTION_USE_PNG) */ 460 461 462 /* END */