jdk-sandbox: comparison src/java.desktop/share/native/libfreetype/src/base/ftobjs.c

equal deleted inserted replaced

-:bcfedddcf4ce
+:da3834261f0c
-/***************************************************************************/
+/****************************************************************************
-/*                                                                         */
+*
-/*  ftobjs.c                                                               */
+* ftobjs.c
-/*                                                                         */
+*
-/*    The FreeType private base classes (body).                            */
+*   The FreeType private base classes (body).
-/*                                                                         */
+*
-/*  Copyright 1996-2018 by                                                 */
+* Copyright (C) 1996-2019 by
-/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
+* David Turner, Robert Wilhelm, and Werner Lemberg.
-/*                                                                         */
+*
-/*  This file is part of the FreeType project, and may only be used,       */
+* This file is part of the FreeType project, and may only be used,
-/*  modified, and distributed under the terms of the FreeType project      */
+* modified, and distributed under the terms of the FreeType project
-/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
+* license, LICENSE.TXT.  By continuing to use, modify, or distribute
-/*  this file you indicate that you have read the license and              */
+* this file you indicate that you have read the license and
-/*  understand and accept it fully.                                        */
+* understand and accept it fully.
-/*                                                                         */
+*
-/***************************************************************************/
+*/
 #include <ft2build.h>
 #include FT_LIST_H
 #include FT_OUTLINE_H
 #include "md5.c"
 #if defined( _MSC_VER )
 #pragma warning( pop )
 #endif
+static const char* const  pixel_modes[] =
+{
+"none",
+"monochrome bitmap",
+"gray 8-bit bitmap",
+"gray 2-bit bitmap",
+"gray 4-bit bitmap",
+"LCD 8-bit bitmap",
+"vertical LCD 8-bit bitmap",
+"BGRA 32-bit color image bitmap"
+};
 #endif /* FT_DEBUG_LEVEL_TRACE */
 #define GRID_FIT_METRICS
 FT_FREE( stream );
 }
 }
-/*************************************************************************/
+/**************************************************************************
-/*                                                                       */
+*
-/* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
+* The macro FT_COMPONENT is used in trace mode.  It is an implicit
-/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
+* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
-/* messages during execution.                                            */
+* messages during execution.
-/*                                                                       */
+*/
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_objs
+#define FT_COMPONENT  objs
 /*************************************************************************/
 /*************************************************************************/
 /*************************************************************************/
 slot->bitmap.buffer = NULL;
 }
 }
-FT_BASE_DEF( void )
+/* overflow-resistant presetting of bitmap position and dimensions; */
+/* also check whether the size is too large for rendering           */
+FT_BASE_DEF( FT_Bool )
 ft_glyphslot_preset_bitmap( FT_GlyphSlot      slot,
 FT_Render_Mode    mode,
 const FT_Vector*  origin )
 {
 FT_Outline*  outline = &slot->outline;
 FT_Bitmap*   bitmap  = &slot->bitmap;
 FT_Pixel_Mode  pixel_mode;
-FT_BBox  cbox;
+FT_BBox  cbox, pbox;
 FT_Pos   x_shift = 0;
 FT_Pos   y_shift = 0;
 FT_Pos   x_left, y_top;
 FT_Pos   width, height, pitch;
-if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) )
+if ( slot->format != FT_GLYPH_FORMAT_OUTLINE )
-return;
+return 1;
 if ( origin )
 {
 x_shift = origin->x;
 y_shift = origin->y;
 /* compute the control box, and grid-fit it, */
 /* taking into account the origin shift      */
 FT_Outline_Get_CBox( outline, &cbox );
-cbox.xMin += x_shift;
+/* rough estimate of pixel box */
-cbox.yMin += y_shift;
+pbox.xMin = ( cbox.xMin >> 6 ) + ( x_shift >> 6 );
-cbox.xMax += x_shift;
+pbox.yMin = ( cbox.yMin >> 6 ) + ( y_shift >> 6 );
-cbox.yMax += y_shift;
+pbox.xMax = ( cbox.xMax >> 6 ) + ( x_shift >> 6 );
+pbox.yMax = ( cbox.yMax >> 6 ) + ( y_shift >> 6 );
+/* tiny remainder box */
+cbox.xMin = ( cbox.xMin & 63 ) + ( x_shift & 63 );
+cbox.yMin = ( cbox.yMin & 63 ) + ( y_shift & 63 );
+cbox.xMax = ( cbox.xMax & 63 ) + ( x_shift & 63 );
+cbox.yMax = ( cbox.yMax & 63 ) + ( y_shift & 63 );
 switch ( mode )
 {
 case FT_RENDER_MODE_MONO:
 pixel_mode = FT_PIXEL_MODE_MONO;
 #if 1
-/* undocumented but confirmed: bbox values get rounded    */
+/* x */
-/* unless the rounded box can collapse for a narrow glyph */
-if ( cbox.xMax - cbox.xMin < 64 )
+/* undocumented but confirmed: bbox values get rounded;    */
-{
+/* we do asymmetric rounding so that the center of a pixel */
-cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+/* gets always included                                    */
-cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax );
-}
+pbox.xMin += ( cbox.xMin + 31 ) >> 6;
-else
+pbox.xMax += ( cbox.xMax + 32 ) >> 6;
-{
-cbox.xMin = FT_PIX_ROUND_LONG( cbox.xMin );
+/* if the bbox collapsed, we add a pixel based on the total */
-cbox.xMax = FT_PIX_ROUND_LONG( cbox.xMax );
+/* rounding remainder to cover most of the original cbox    */
-}
+if ( pbox.xMin == pbox.xMax )
-if ( cbox.yMax - cbox.yMin < 64 )
+{
-{
+if ( ( ( cbox.xMin + 31 ) & 63 ) - 31 +
-cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
+( ( cbox.xMax + 32 ) & 63 ) - 32 < 0 )
-cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax );
+pbox.xMin -= 1;
-}
+else
-else
+pbox.xMax += 1;
-{
+}
-cbox.yMin = FT_PIX_ROUND_LONG( cbox.yMin );
-cbox.yMax = FT_PIX_ROUND_LONG( cbox.yMax );
+/* y */
-}
+pbox.yMin += ( cbox.yMin + 31 ) >> 6;
+pbox.yMax += ( cbox.yMax + 32 ) >> 6;
+if ( pbox.yMin == pbox.yMax )
+{
+if ( ( ( cbox.yMin + 31 ) & 63 ) - 31 +
+( ( cbox.yMax + 32 ) & 63 ) - 32 < 0 )
+pbox.yMin -= 1;
+else
+pbox.yMax += 1;
+}
+break;
 #else
-cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+goto Adjust;
-cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
-cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax );
-cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax );
 #endif
-break;
 case FT_RENDER_MODE_LCD:
 pixel_mode = FT_PIXEL_MODE_LCD;
-ft_lcd_padding( &cbox.xMin, &cbox.xMax, slot );
+ft_lcd_padding( &cbox, slot, mode );
-goto Round;
+goto Adjust;
 case FT_RENDER_MODE_LCD_V:
 pixel_mode = FT_PIXEL_MODE_LCD_V;
-ft_lcd_padding( &cbox.yMin, &cbox.yMax, slot );
+ft_lcd_padding( &cbox, slot, mode );
-goto Round;
+goto Adjust;
 case FT_RENDER_MODE_NORMAL:
 case FT_RENDER_MODE_LIGHT:
 default:
 pixel_mode = FT_PIXEL_MODE_GRAY;
-Round:
+Adjust:
-cbox.xMin = FT_PIX_FLOOR( cbox.xMin );
+pbox.xMin += cbox.xMin >> 6;
-cbox.yMin = FT_PIX_FLOOR( cbox.yMin );
+pbox.yMin += cbox.yMin >> 6;
-cbox.xMax = FT_PIX_CEIL_LONG( cbox.xMax );
+pbox.xMax += ( cbox.xMax + 63 ) >> 6;
-cbox.yMax = FT_PIX_CEIL_LONG( cbox.yMax );
+pbox.yMax += ( cbox.yMax + 63 ) >> 6;
 }
-x_shift = SUB_LONG( x_shift, cbox.xMin );
+x_left = pbox.xMin;
-y_shift = SUB_LONG( y_shift, cbox.yMin );
+y_top  = pbox.yMax;
-x_left = cbox.xMin >> 6;
+width  = pbox.xMax - pbox.xMin;
-y_top  = cbox.yMax >> 6;
+height = pbox.yMax - pbox.yMin;
-width  = ( (FT_ULong)cbox.xMax - (FT_ULong)cbox.xMin ) >> 6;
-height = ( (FT_ULong)cbox.yMax - (FT_ULong)cbox.yMin ) >> 6;
 switch ( pixel_mode )
 {
 case FT_PIXEL_MODE_MONO:
 pitch = ( ( width + 15 ) >> 4 ) << 1;
 bitmap->pixel_mode = (unsigned char)pixel_mode;
 bitmap->num_grays  = 256;
 bitmap->width      = (unsigned int)width;
 bitmap->rows       = (unsigned int)height;
 bitmap->pitch      = pitch;
+if ( pbox.xMin < -0x8000 || pbox.xMax > 0x7FFF ||
+pbox.yMin < -0x8000 || pbox.yMax > 0x7FFF )
+{
+FT_TRACE3(( "ft_glyphslot_preset_bitmap: [%ld %ld %ld %ld]\n",
+pbox.xMin, pbox.yMin, pbox.xMax, pbox.yMax ));
+return 1;
+}
+return 0;
 }
 FT_BASE_DEF( void )
 ft_glyphslot_set_bitmap( FT_GlyphSlot  slot,
 * The general rules are:
 *
 * - Do only auto-hinting if we have
 *
 *   - a hinter module,
-*   - a scalable font format dealing with outlines,
+*   - a scalable font,
 *   - not a tricky font, and
 *   - no transforms except simple slants and/or rotations by
 *     integer multiples of 90 degrees.
 *
 * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't
 */
 if ( hinter                                           &&
 !( load_flags & FT_LOAD_NO_HINTING )             &&
 !( load_flags & FT_LOAD_NO_AUTOHINT )            &&
-FT_DRIVER_IS_SCALABLE( driver )                  &&
+FT_IS_SCALABLE( face )                           &&
-FT_DRIVER_USES_OUTLINES( driver )                &&
 !FT_IS_TRICKY( face )                            &&
 ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM )    ||
 ( face->internal->transform_matrix.yx == 0 &&
 face->internal->transform_matrix.xx != 0 ) ||
 ( face->internal->transform_matrix.xx == 0 &&
 /* only the new Adobe engine (for both CFF and Type 1) is `light'; */
 /* we use `strstr' to catch both `Type 1' and `CID Type 1'         */
 is_light_type1 =
-ft_strstr( FT_Get_Font_Format( face ), "Type 1" ) != NULL   &&
+ft_strstr( FT_Get_Font_Format( face ), "Type 1" ) != NULL &&
 ((PS_Driver)driver)->hinting_engine == FT_HINTING_ADOBE;
 /* the check for `num_locations' assures that we actually    */
 /* test for instructions in a TTF and not in a CFF-based OTF */
 /*                                                           */
 if ( error )
 goto Exit;
 #ifdef GRID_FIT_METRICS
 if ( !( load_flags & FT_LOAD_NO_HINTING ) )
-ft_glyphslot_grid_fit_metrics( slot,
+ft_glyphslot_grid_fit_metrics(
-FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) );
+slot,
+FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) );
 #endif
 }
 }
 Load_Ok:
 /* transform advance */
 FT_Vector_Transform( &slot->advance, &internal->transform_matrix );
 }
 }
+slot->glyph_index          = glyph_index;
+slot->internal->load_flags = load_flags;
 /* do we need to render the image or preset the bitmap now? */
 if ( !error                                    &&
 ( load_flags & FT_LOAD_NO_SCALE ) == 0    &&
 slot->format != FT_GLYPH_FORMAT_BITMAP    &&
 slot->format != FT_GLYPH_FORMAT_COMPOSITE )
 error = FT_Render_Glyph( slot, mode );
 else
 ft_glyphslot_preset_bitmap( slot, mode, NULL );
 }
-FT_TRACE5(( "FT_Load_Glyph: index %d, flags %x\n",
+#ifdef FT_DEBUG_LEVEL_TRACE
-glyph_index, load_flags               ));
+FT_TRACE5(( "FT_Load_Glyph: index %d, flags 0x%x\n",
+glyph_index, load_flags ));
 FT_TRACE5(( "  x advance: %f\n", slot->advance.x / 64.0 ));
 FT_TRACE5(( "  y advance: %f\n", slot->advance.y / 64.0 ));
 FT_TRACE5(( "  linear x advance: %f\n",
 slot->linearHoriAdvance / 65536.0 ));
 FT_TRACE5(( "  linear y advance: %f\n",
 slot->linearVertAdvance / 65536.0 ));
-FT_TRACE5(( "  bitmap %dx%d, mode %d\n",
+FT_TRACE5(( "  bitmap %dx%d, %s (mode %d)\n",
-slot->bitmap.width, slot->bitmap.rows,
+slot->bitmap.width,
-slot->bitmap.pixel_mode               ));
+slot->bitmap.rows,
+pixel_modes[slot->bitmap.pixel_mode],
+slot->bitmap.pixel_mode ));
+#endif
 Exit:
 return error;
 }
 driver->root.memory,
 driver );
 }
-/*************************************************************************/
+/**************************************************************************
-/*                                                                       */
+*
-/* <Function>                                                            */
+* @Function:
-/*    find_unicode_charmap                                               */
+*   find_unicode_charmap
-/*                                                                       */
+*
-/* <Description>                                                         */
+* @Description:
-/*    This function finds a Unicode charmap, if there is one.            */
+*   This function finds a Unicode charmap, if there is one.
-/*    And if there is more than one, it tries to favour the more         */
+*   And if there is more than one, it tries to favour the more
-/*    extensive one, i.e., one that supports UCS-4 against those which   */
+*   extensive one, i.e., one that supports UCS-4 against those which
-/*    are limited to the BMP (said UCS-2 encoding.)                      */
+*   are limited to the BMP (said UCS-2 encoding.)
-/*                                                                       */
+*
-/*    This function is called from open_face() (just below), and also    */
+*   This function is called from open_face() (just below), and also
-/*    from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ).                */
+*   from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ).
-/*                                                                       */
+*/
 static FT_Error
 find_unicode_charmap( FT_Face  face )
 {
 FT_CharMap*  first;
 FT_CharMap*  cur;
 if ( !first )
 return FT_THROW( Invalid_CharMap_Handle );
 /*
-*  The original TrueType specification(s) only specified charmap
+* The original TrueType specification(s) only specified charmap
-*  formats that are capable of mapping 8 or 16 bit character codes to
+* formats that are capable of mapping 8 or 16 bit character codes to
-*  glyph indices.
+* glyph indices.
 *
-*  However, recent updates to the Apple and OpenType specifications
+* However, recent updates to the Apple and OpenType specifications
-*  introduced new formats that are capable of mapping 32-bit character
+* introduced new formats that are capable of mapping 32-bit character
-*  codes as well.  And these are already used on some fonts, mainly to
+* codes as well.  And these are already used on some fonts, mainly to
-*  map non-BMP Asian ideographs as defined in Unicode.
+* map non-BMP Asian ideographs as defined in Unicode.
 *
-*  For compatibility purposes, these fonts generally come with
+* For compatibility purposes, these fonts generally come with
-*  *several* Unicode charmaps:
+* *several* Unicode charmaps:
 *
-*   - One of them in the "old" 16-bit format, that cannot access
+* - One of them in the "old" 16-bit format, that cannot access
-*     all glyphs in the font.
+*   all glyphs in the font.
 *
-*   - Another one in the "new" 32-bit format, that can access all
+* - Another one in the "new" 32-bit format, that can access all
-*     the glyphs.
+*   the glyphs.
 *
-*  This function has been written to always favor a 32-bit charmap
+* This function has been written to always favor a 32-bit charmap
-*  when found.  Otherwise, a 16-bit one is returned when found.
+* when found.  Otherwise, a 16-bit one is returned when found.
 */
 /* Since the `interesting' table, with IDs (3,10), is normally the */
 /* last one, we loop backwards.  This loses with type1 fonts with  */
 /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP  */
 return FT_THROW( Invalid_CharMap_Handle );
 }
-/*************************************************************************/
+/**************************************************************************
-/*                                                                       */
+*
-/* <Function>                                                            */
+* @Function:
-/*    find_variant_selector_charmap                                      */
+*   find_variant_selector_charmap
-/*                                                                       */
+*
-/* <Description>                                                         */
+* @Description:
-/*    This function finds the variant selector charmap, if there is one. */
+*   This function finds the variant selector charmap, if there is one.
-/*    There can only be one (platform=0, specific=5, format=14).         */
+*   There can only be one (platform=0, specific=5, format=14).
-/*                                                                       */
+*/
 static FT_CharMap
 find_variant_selector_charmap( FT_Face  face )
 {
 FT_CharMap*  first;
 FT_CharMap*  end;
 return NULL;
 }
-/*************************************************************************/
+/**************************************************************************
-/*                                                                       */
+*
-/* <Function>                                                            */
+* @Function:
-/*    open_face                                                          */
+*   open_face
-/*                                                                       */
+*
-/* <Description>                                                         */
+* @Description:
-/*    This function does some work for FT_Open_Face().                   */
+*   This function does some work for FT_Open_Face().
-/*                                                                       */
+*/
 static FT_Error
 open_face( FT_Driver      driver,
 FT_Stream      *astream,
 FT_Bool        external_stream,
 FT_Long        face_index,
 FT_Face             *aface,
 const FT_Open_Args  *args )
 {
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_raccess
+#define FT_COMPONENT  raccess
 FT_Memory  memory = library->memory;
 FT_Error   error  = FT_ERR( Unknown_File_Format );
 FT_UInt    i;
-char *     file_names[FT_RACCESS_N_RULES];
+char*      file_names[FT_RACCESS_N_RULES];
 FT_Long    offsets[FT_RACCESS_N_RULES];
 FT_Error   errors[FT_RACCESS_N_RULES];
 FT_Bool    is_darwin_vfs, vfs_rfork_has_no_font = FALSE; /* not tested */
 FT_Open_Args  args2;
 error = FT_ERR( Unknown_File_Format );
 return error;
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_objs
+#define FT_COMPONENT  objs
 }
 /* Check for some macintosh formats without Carbon framework.    */
 error = IsMacBinary( library, stream, face_index, aface );
 if ( FT_ERR_EQ( error, Unknown_File_Format ) )
 {
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_raccess
+#define FT_COMPONENT  raccess
 #ifdef FT_DEBUG_LEVEL_TRACE
 FT_TRACE3(( "Try as dfont: " ));
 if ( !( args->flags & FT_OPEN_MEMORY ) )
 FT_TRACE3(( "%s ...", args->pathname ));
 error = IsMacResource( library, stream, 0, face_index, aface );
 FT_TRACE3(( "%s\n", error ? "failed" : "successful" ));
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_objs
+#define FT_COMPONENT  objs
 }
 if ( ( FT_ERR_EQ( error, Unknown_File_Format )      ||
 FT_ERR_EQ( error, Invalid_Stream_Operation ) ) &&
 if ( clazz->attach_file )
 error = clazz->attach_file( face, stream );
 /* close the attached stream */
 FT_Stream_Free( stream,
-(FT_Bool)( parameters->stream &&
+FT_BOOL( parameters->stream                     &&
 ( parameters->flags & FT_OPEN_STREAM ) ) );
 Exit:
 return error;
 }
 if ( !face )
 return FT_THROW( Invalid_Face_Handle );
-if ( encoding == FT_ENCODING_NONE )
+/* FT_ENCODING_NONE is a valid encoding for BDF, PCF, and Windows FNT */
+if ( encoding == FT_ENCODING_NONE && !face->num_charmaps )
 return FT_THROW( Invalid_Argument );
 /* FT_ENCODING_UNICODE is special.  We try to find the `best' Unicode */
 /* charmap available, i.e., one with UCS-4 characters, if possible.   */
 /*                                                                    */
 for ( ; cur < limit; cur++ )
 {
 if ( cur[0]->encoding == encoding )
 {
 face->charmap = cur[0];
-return 0;
+return FT_Err_Ok;
 }
 }
 return FT_THROW( Invalid_Argument );
 }
 cur = face->charmaps;
 if ( !cur || !charmap )
 return FT_THROW( Invalid_CharMap_Handle );
-if ( FT_Get_CMap_Format( charmap ) == 14 )
-return FT_THROW( Invalid_Argument );
 limit = cur + face->num_charmaps;
 for ( ; cur < limit; cur++ )
 {
-if ( cur[0] == charmap )
+if ( cur[0] == charmap                    &&
+FT_Get_CMap_Format ( charmap ) != 14 )
 {
 face->charmap = cur[0];
 return FT_Err_Ok;
 }
 }
 FT_Render_Glyph_Internal( FT_Library      library,
 FT_GlyphSlot    slot,
 FT_Render_Mode  render_mode )
 {
 FT_Error     error = FT_Err_Ok;
+FT_Face      face  = slot->face;
 FT_Renderer  renderer;
-/* if it is already a bitmap, no need to do anything */
 switch ( slot->format )
 {
 case FT_GLYPH_FORMAT_BITMAP:   /* already a bitmap, don't do anything */
 break;
 default:
+if ( slot->internal->load_flags & FT_LOAD_COLOR )
+{
+FT_LayerIterator  iterator;
+FT_UInt  base_glyph = slot->glyph_index;
+FT_Bool  have_layers;
+FT_UInt  glyph_index;
+FT_UInt  color_index;
+/* check whether we have colored glyph layers */
+iterator.p  = NULL;
+have_layers = FT_Get_Color_Glyph_Layer( face,
+base_glyph,
+&glyph_index,
+&color_index,
+&iterator );
+if ( have_layers )
+{
+error = FT_New_GlyphSlot( face, NULL );
+if ( !error )
+{
+TT_Face       ttface = (TT_Face)face;
+SFNT_Service  sfnt   = (SFNT_Service)ttface->sfnt;
+do
+{
+FT_Int32  load_flags = slot->internal->load_flags;
+/* disable the `FT_LOAD_COLOR' flag to avoid recursion */
+/* right here in this function                         */
+load_flags &= ~FT_LOAD_COLOR;
+/* render into the new `face->glyph' glyph slot */
+load_flags |= FT_LOAD_RENDER;
+error = FT_Load_Glyph( face, glyph_index, load_flags );
+if ( error )
+break;
+/* blend new `face->glyph' into old `slot'; */
+/* at the first call, `slot' is still empty */
+error = sfnt->colr_blend( ttface,
+color_index,
+slot,
+face->glyph );
+if ( error )
+break;
+} while ( FT_Get_Color_Glyph_Layer( face,
+base_glyph,
+&glyph_index,
+&color_index,
+&iterator ) );
+if ( !error )
+slot->format = FT_GLYPH_FORMAT_BITMAP;
+/* this call also restores `slot' as the glyph slot */
+FT_Done_GlyphSlot( face->glyph );
+}
+if ( !error )
+return error;
+/* Failed to do the colored layer.  Draw outline instead. */
+slot->format = FT_GLYPH_FORMAT_OUTLINE;
+}
+}
 {
 FT_ListNode  node = NULL;
 /* small shortcut for the very common case */
 }
 #ifdef FT_DEBUG_LEVEL_TRACE
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_bitmap
+#define FT_COMPONENT  checksum
 /*
 * Computing the MD5 checksum is expensive, unnecessarily distorting a
 * possible profiling of FreeType if compiled with tracing support.  For
 * this reason, we execute the following code only if explicitly
 * requested.
 */
 /* we use FT_TRACE3 in this block */
-if ( !error                             &&
+if ( !error                               &&
-ft_trace_levels[trace_bitmap] >= 3 &&
+ft_trace_levels[trace_checksum] >= 3 &&
-slot->bitmap.buffer                )
+slot->bitmap.buffer                  )
 {
 FT_Bitmap  bitmap;
 FT_Error   err;
 int            i, j;
 int            rows  = (int)bitmap.rows;
 int            pitch = bitmap.pitch;
-FT_TRACE3(( "FT_Render_Glyph: bitmap %dx%d, mode %d\n",
+FT_TRACE3(( "FT_Render_Glyph: bitmap %dx%d, %s (mode %d)\n",
-rows, pitch, slot->bitmap.pixel_mode ));
+pitch,
+rows,
+pixel_modes[slot->bitmap.pixel_mode],
+slot->bitmap.pixel_mode ));
 for ( i = 0; i < rows; i++ )
 for ( j = 0; j < pitch; j++ )
 coverage += bitmap.buffer[i * pitch + j];
 /*
 * Dump bitmap in Netpbm format (PBM or PGM).
 */
 /* we use FT_TRACE7 in this block */
-if ( !error                             &&
+if ( !error                               &&
-ft_trace_levels[trace_bitmap] >= 7 &&
+ft_trace_levels[trace_checksum] >= 7 )
-slot->bitmap.rows  < 128U          &&
+{
-slot->bitmap.width < 128U          &&
+if ( slot->bitmap.rows  < 128U &&
-slot->bitmap.buffer                )
+slot->bitmap.width < 128U &&
-{
+slot->bitmap.buffer       )
-int  rows  = (int)slot->bitmap.rows;
+{
-int  width = (int)slot->bitmap.width;
+int  rows  = (int)slot->bitmap.rows;
-int  pitch =      slot->bitmap.pitch;
+int  width = (int)slot->bitmap.width;
-int  i, j, m;
+int  pitch =      slot->bitmap.pitch;
-unsigned char*  topleft = slot->bitmap.buffer;
+int  i, j, m;
-if ( pitch < 0 )
+unsigned char*  topleft = slot->bitmap.buffer;
-topleft -= pitch * ( rows - 1 );
-FT_TRACE7(( "Netpbm image: start\n" ));
+if ( pitch < 0 )
-switch ( slot->bitmap.pixel_mode )
+topleft -= pitch * ( rows - 1 );
-{
-case FT_PIXEL_MODE_MONO:
+FT_TRACE7(( "Netpbm image: start\n" ));
-FT_TRACE7(( "P1 %d %d\n", width, rows ));
+switch ( slot->bitmap.pixel_mode )
-for ( i = 0; i < rows; i++ )
 {
-for ( j = 0; j < width; )
+case FT_PIXEL_MODE_MONO:
-for ( m = 128; m > 0 && j < width; m >>= 1, j++ )
+FT_TRACE7(( "P1 %d %d\n", width, rows ));
-FT_TRACE7(( " %d", ( topleft[i * pitch + j / 8] & m ) != 0 ));
+for ( i = 0; i < rows; i++ )
-FT_TRACE7(( "\n" ));
+{
+for ( j = 0; j < width; )
+for ( m = 128; m > 0 && j < width; m >>= 1, j++ )
+FT_TRACE7(( " %d",
+( topleft[i * pitch + j / 8] & m ) != 0 ));
+FT_TRACE7(( "\n" ));
+}
+break;
+default:
+FT_TRACE7(( "P2 %d %d 255\n", width, rows ));
+for ( i = 0; i < rows; i++ )
+{
+for ( j = 0; j < width; j += 1 )
+FT_TRACE7(( " %3u", topleft[i * pitch + j] ));
+FT_TRACE7(( "\n" ));
+}
 }
-break;
+FT_TRACE7(( "Netpbm image: end\n" ));
+}
-default:
+else
-FT_TRACE7(( "P2 %d %d 255\n", width, rows ));
+FT_TRACE7(( "Netpbm image: too large, omitted\n" ));
-for ( i = 0; i < rows; i++ )
-{
-for ( j = 0; j < width; j += 1 )
-FT_TRACE7(( " %3u", topleft[i * pitch + j] ));
-FT_TRACE7(( "\n" ));
-}
-}
-FT_TRACE7(( "Netpbm image: end\n" ));
 }
 #undef  FT_COMPONENT
-#define FT_COMPONENT  trace_objs
+#define FT_COMPONENT  objs
 #endif /* FT_DEBUG_LEVEL_TRACE */
 return error;
 }
 /*************************************************************************/
 /*************************************************************************/
 /*************************************************************************/
-/*************************************************************************/
+/**************************************************************************
-/*                                                                       */
+*
-/* <Function>                                                            */
+* @Function:
-/*    Destroy_Module                                                     */
+*   Destroy_Module
-/*                                                                       */
+*
-/* <Description>                                                         */
+* @Description:
-/*    Destroys a given module object.  For drivers, this also destroys   */
+*   Destroys a given module object.  For drivers, this also destroys
-/*    all child faces.                                                   */
+*   all child faces.
-/*                                                                       */
+*
-/* <InOut>                                                               */
+* @InOut:
-/*    module :: A handle to the target driver object.                    */
+*   module ::
-/*                                                                       */
+*     A handle to the target driver object.
-/* <Note>                                                                */
+*
-/*    The driver _must_ be LOCKED!                                       */
+* @Note:
-/*                                                                       */
+*   The driver _must_ be LOCKED!
+*/
 static void
 Destroy_Module( FT_Module  module )
 {
 FT_Memory         memory  = module->memory;
 FT_Module_Class*  clazz   = module->clazz;
 }
 service = (FT_Service_Properties)interface;
 if ( set )
-missing_func = (FT_Bool)( !service->set_property );
+missing_func = FT_BOOL( !service->set_property );
 else
-missing_func = (FT_Bool)( !service->get_property );
+missing_func = FT_BOOL( !service->get_property );
 if ( missing_func )
 {
 FT_ERROR(( "%s: property service of module `%s' is broken\n",
 func_name, module_name ));
 if ( FT_NEW( library ) )
 return error;
 library->memory = memory;
-#ifdef FT_CONFIG_OPTION_PIC
-/* initialize position independent code containers */
-error = ft_pic_container_init( library );
-if ( error )
-goto Fail;
-#endif
 library->version_major = FREETYPE_MAJOR;
 library->version_minor = FREETYPE_MINOR;
 library->version_patch = FREETYPE_PATCH;
 library->refcount = 1;
 /* That's ok now */
 *alibrary = library;
 return FT_Err_Ok;
-#ifdef FT_CONFIG_OPTION_PIC
-Fail:
-ft_pic_container_destroy( library );
-FT_FREE( library );
-return error;
-#endif
 }
 /* documentation is in freetype.h */
 * Close all faces in the library.  If we don't do this, we can have
 * some subtle memory leaks.
 *
 * Example:
 *
-*  - the cff font driver uses the pshinter module in cff_size_done
+* - the cff font driver uses the pshinter module in cff_size_done
-*  - if the pshinter module is destroyed before the cff font driver,
+* - if the pshinter module is destroyed before the cff font driver,
-*    opened FT_Face objects managed by the driver are not properly
+*   opened FT_Face objects managed by the driver are not properly
-*    destroyed, resulting in a memory leak
+*   destroyed, resulting in a memory leak
 *
 * Some faces are dependent on other faces, like Type42 faces that
 * depend on TrueType faces synthesized internally.
 *
 * The order of drivers should be specified in driver_name[].
 }
 }
 }
 #endif
-#ifdef FT_CONFIG_OPTION_PIC
-/* Destroy pic container contents */
-ft_pic_container_destroy( library );
-#endif
 FT_FREE( library );
 Exit:
 return FT_Err_Ok;
 }
 return error;
 }
+/* documentation is in freetype.h */
+FT_EXPORT_DEF( FT_Bool )
+FT_Get_Color_Glyph_Layer( FT_Face            face,
+FT_UInt            base_glyph,
+FT_UInt           *aglyph_index,
+FT_UInt           *acolor_index,
+FT_LayerIterator*  iterator )
+{
+TT_Face       ttface;
+SFNT_Service  sfnt;
+if ( !face                                   ||
+!aglyph_index                           ||
+!acolor_index                           ||
+!iterator                               ||
+base_glyph >= (FT_UInt)face->num_glyphs )
+return 0;
+if ( !FT_IS_SFNT( face ) )
+return 0;
+ttface = (TT_Face)face;
+sfnt   = (SFNT_Service)ttface->sfnt;
+if ( sfnt->get_colr_layer )
+return sfnt->get_colr_layer( ttface,
+base_glyph,
+aglyph_index,
+acolor_index,
+iterator );
+else
+return 0;
+}
 /* END */

changeset 54876	da3834261f0c
parent 49234	3375a8039fde