kc3-lang/freetype/src/pfr/pfrobjs.c

• Show log

  Commit

• Hash : 779afe4b
  Author :
  Date : 2003-06-22T15:33:53
  

  * src/winfonts/winfnt.c (FNT_Load_Glyph): Use first_char in computation of glyph_index. (FNT_Size_Set_Pixels): To find a strike, first check pixel_height only, then try to find a better hit by comparing pixel_width also. Without this fix it isn't possible to access all strikes. Also compute metrics.max_advance to be in sync with other bitmap drivers. * src/base/ftobjs.c (FT_Set_Char_Size): Remove redundant code. (FT_Set_Pixel_Size): Assign value to `metrics' after validation of arguments. Synchronize computation of height and width for bitmap strikes. The `width' field in the FT_Bitmap_Size structure is now only useful to enumerate different strikes. The `max_advance' field of the FT_Size_Metrics structure should be used to get the (maximum) width of a strike. * src/bdf/bdfdrivr.c (BDF_Face_Init): Don't use AVERAGE_WIDTH for computing `available_sizes->width' but make it always equal to `available_sizes->height'. * src/pcf/pcfread.c (pcf_load_font): Don't use RESOLUTION_X for computing `available_sizes->width' but make it always equal to `available_sizes->height'. * src/truetype/ttdriver.c (Set_Pixel_Sizes): Pass only single argument to function. * src/psnames/psmodule.c (ps_unicode_value): Handle `.' after `uniXXXX' and `uXXXX[X[X]]'. * src/bdf/bdfdrivr.c: s/FT_Err_/BDF_Err/. * src/cache/ftccache.c, src/cache/ftcsbits.c, src/cache/ftlru.c: s/FT_Err_/FTC_Err_/. * src/cff/cffcmap.c: s/FT_Err_/CFF_Err_/. * src/pcf/pcfdrivr.c: s/FT_Err_/PCF_Err_/. * src/psaux/t1cmap.c: Include psauxerr.h. s/FT_Err_/PSaux_Err_/. * src/pshinter/pshnterr.h: New file. * src/pshinter/rules.mk: Updated. * src/pshinter/pshalgo.c, src/pshinter/pshrec.c: Include pshnterr.h. s/FT_Err_/PSH_Err_/. * src/pfr/pfrdrivr.c, src/pfr/pfrobjs.c, src/pfr/pfrsbit.c: s/FT_Err_/PFR_Err_/. * src/sfnt/sfdriver.c, src/sfnt/sfobjs.c, src/sfnt/ttcmap0.c, src/sfnt/ttload.c: s/FT_Err_/SFNT_Err_/. * src/truetype/ttgload.c: s/FT_Err_/TT_Err_/. * src/gzip/ftgzip.c: Load FT_MODULE_ERRORS_H and define FT_ERR_PREFIX and FT_ERR_BASE. s/FT_Err_/Gzip_Err_/.

Download

• src/pfr/pfrobjs.c

• /***************************************************************************/
  /*                                                                         */
  /*  pfrobjs.c                                                              */
  /*                                                                         */
  /*    FreeType PFR object methods (body).                                  */
  /*                                                                         */
  /*  Copyright 2002, 2003 by                                                */
  /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  /*                                                                         */
  /*  This file is part of the FreeType project, and may only be used,       */
  /*  modified, and distributed under the terms of the FreeType project      */
  /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  /*  this file you indicate that you have read the license and              */
  /*  understand and accept it fully.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include "pfrobjs.h"
  #include "pfrload.h"
  #include "pfrgload.h"
  #include "pfrcmap.h"
  #include "pfrsbit.h"
  #include FT_OUTLINE_H
  #include FT_INTERNAL_DEBUG_H
  
  #include "pfrerror.h"
  
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_pfr
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                     FACE OBJECT METHODS                       *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    FT_LOCAL_DEF( void )
    pfr_face_done( PFR_Face  face )
    {
      FT_Memory  memory = face->root.driver->root.memory;
  
  
      /* we don't want dangling pointers */
      face->root.family_name = NULL;
      face->root.style_name  = NULL;
      
      /* finalize the physical font record */
      pfr_phy_font_done( &face->phy_font, FT_FACE_MEMORY( face ) );
  
      /* no need to finalize the logical font or the header */
      FT_FREE( face->root.available_sizes );
    }
  
  
    FT_LOCAL_DEF( FT_Error )
    pfr_face_init( FT_Stream      stream,
                   PFR_Face       face,
                   FT_Int         face_index,
                   FT_Int         num_params,
                   FT_Parameter*  params )
    {
      FT_Error  error;
  
      FT_UNUSED( num_params );
      FT_UNUSED( params );
  
  
      /* load the header and check it */
      error = pfr_header_load( &face->header, stream );
      if ( error )
        goto Exit;
  
      if ( !pfr_header_check( &face->header ) )
      {
        FT_TRACE4(( "pfr_face_init: not a valid PFR font\n" ));
        error = PFR_Err_Unknown_File_Format;
        goto Exit;
      }
  
      /* check face index */
      {
        FT_UInt  num_faces;
  
  
        error = pfr_log_font_count( stream,
                                    face->header.log_dir_offset,
                                    &num_faces );
        if ( error )
          goto Exit;
  
        face->root.num_faces = num_faces;
      }
  
      if ( face_index < 0 )
        goto Exit;
  
      if ( face_index >= face->root.num_faces )
      {
        FT_ERROR(( "pfr_face_init: invalid face index\n" ));
        error = PFR_Err_Invalid_Argument;
        goto Exit;
      }
  
      /* load the face */
      error = pfr_log_font_load(
                 &face->log_font, stream, face_index,
                 face->header.log_dir_offset,
                 FT_BOOL( face->header.phy_font_max_size_high != 0 ) );
      if ( error )
        goto Exit;
  
      /* now load the physical font descriptor */
      error = pfr_phy_font_load( &face->phy_font, stream,
                                 face->log_font.phys_offset,
                                 face->log_font.phys_size );
      if ( error )
        goto Exit;
  
      /* now, set-up all root face fields */
      {
        FT_Face      root     = FT_FACE( face );
        PFR_PhyFont  phy_font = &face->phy_font;
  
  
        root->face_index = face_index;
        root->num_glyphs = phy_font->num_chars;
        root->face_flags = FT_FACE_FLAG_SCALABLE;
  
        if ( (phy_font->flags & PFR_PHY_PROPORTIONAL) == 0 )
          root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
  
        if ( phy_font->flags & PFR_PHY_VERTICAL )
          root->face_flags |= FT_FACE_FLAG_VERTICAL;
        else
          root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
  
        if ( phy_font->num_strikes > 0 )
          root->face_flags |= FT_FACE_FLAG_FIXED_SIZES;
  
        if ( phy_font->num_kern_pairs > 0 )
          root->face_flags |= FT_FACE_FLAG_KERNING;
  
        /* If no family name was found in the "undocumented" auxiliary
         * data, use the font ID instead.  This sucks but is better than
         * nothing.
         */
        root->family_name = phy_font->family_name;
        if ( root->family_name == NULL )
          root->family_name = phy_font->font_id;
  
        /* note that the style name can be NULL in certain PFR fonts,
         * probably meaning "Regular"
         */
        root->style_name = phy_font->style_name;
  
        root->num_fixed_sizes = 0;
        root->available_sizes = 0;
  
        root->bbox         = phy_font->bbox;
        root->units_per_EM = (FT_UShort)phy_font->outline_resolution;
        root->ascender     = (FT_Short) phy_font->bbox.yMax;
        root->descender    = (FT_Short) phy_font->bbox.yMin;
        root->height       = (FT_Short)(
          ( ( root->ascender - root->descender ) * 12 ) / 10 );
  
        if ( phy_font->num_strikes > 0 )
        {
          FT_UInt          n, count = phy_font->num_strikes;
          FT_Bitmap_Size*  size;
          PFR_Strike       strike;
          FT_Memory        memory = root->stream->memory;
           
           
          if ( FT_NEW_ARRAY( root->available_sizes, count ) )
            goto Exit;
           
          size   = root->available_sizes;
          strike = phy_font->strikes;
          for ( n = 0; n < count; n++, size++, strike++ )
          {
            size->height = (FT_UShort)strike->y_ppm;
            size->width  = (FT_UShort)strike->x_ppm;
          }
          root->num_fixed_sizes = count;
        }
  
        /* now compute maximum advance width */
        if ( ( phy_font->flags & PFR_PHY_PROPORTIONAL ) == 0 )
          root->max_advance_width = (FT_Short)phy_font->standard_advance;
        else
        {
          FT_Int    max = 0;
          FT_UInt   count = phy_font->num_chars;
          PFR_Char  gchar = phy_font->chars;
  
  
          for ( ; count > 0; count--, gchar++ )
          {
            if ( max < gchar->advance )
              max = gchar->advance;
          }
  
          root->max_advance_width = (FT_Short)max;
        }
  
        root->max_advance_height = root->height;
  
        root->underline_position  = (FT_Short)( - root->units_per_EM / 10 );
        root->underline_thickness = (FT_Short)(   root->units_per_EM / 30 );
  
        /* create charmap */
        {
          FT_CharMapRec  charmap;
  
  
          charmap.face        = root;
          charmap.platform_id = 3;
          charmap.encoding_id = 1;
          charmap.encoding    = FT_ENCODING_UNICODE;
  
          FT_CMap_New( &pfr_cmap_class_rec, NULL, &charmap, NULL );
  
  #if 0
          /* Select default charmap */
          if (root->num_charmaps)
            root->charmap = root->charmaps[0];
  #endif
        }
  
        /* check whether we've loaded any kerning pairs */
        if ( phy_font->num_kern_pairs )
          root->face_flags |= FT_FACE_FLAG_KERNING;
      }
  
    Exit:
      return error;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                    SLOT OBJECT METHOD                         *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    FT_LOCAL_DEF( FT_Error )
    pfr_slot_init( PFR_Slot  slot )
    {
      FT_GlyphLoader  loader = slot->root.internal->loader;
  
      pfr_glyph_init( &slot->glyph, loader );
  
      return 0;
    }
  
  
    FT_LOCAL_DEF( void )
    pfr_slot_done( PFR_Slot  slot )
    {
      pfr_glyph_done( &slot->glyph );
    }
  
  
    FT_LOCAL_DEF( FT_Error )
    pfr_slot_load( PFR_Slot  slot,
                   PFR_Size  size,
                   FT_UInt   gindex,
                   FT_Int32  load_flags )
    {
      FT_Error     error;
      PFR_Face     face    = (PFR_Face)slot->root.face;
      PFR_Char     gchar;
      FT_Outline*  outline = &slot->root.outline;
      FT_ULong     gps_offset;
  
  
      if ( gindex > 0 )
        gindex--;
  
      /* check that the glyph index is correct */
      FT_ASSERT( gindex < face->phy_font.num_chars );
  
      /* try to load an embedded bitmap */
      if ( ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_BITMAP ) ) == 0 )
      {
        error = pfr_slot_load_bitmap( slot, size, gindex );
        if ( error == 0 )
          goto Exit;
      }
  
      if ( load_flags & FT_LOAD_SBITS_ONLY )
      {
        error = PFR_Err_Invalid_Argument;
        goto Exit;
      }
  
      gchar               = face->phy_font.chars + gindex;
      slot->root.format   = FT_GLYPH_FORMAT_OUTLINE;
      outline->n_points   = 0;
      outline->n_contours = 0;
      gps_offset          = face->header.gps_section_offset;
  
      /* load the glyph outline (FT_LOAD_NO_RECURSE isn't supported) */
      error = pfr_glyph_load( &slot->glyph, face->root.stream,
                              gps_offset, gchar->gps_offset, gchar->gps_size );
  
      if ( !error )
      {
        FT_BBox            cbox;
        FT_Glyph_Metrics*  metrics = &slot->root.metrics;
        FT_Pos             advance;
        FT_Int             em_metrics, em_outline;
        FT_Bool            scaling;
  
  
        scaling = FT_BOOL( ( load_flags & FT_LOAD_NO_SCALE ) == 0 );
  
        /* copy outline data */
        *outline = slot->glyph.loader->base.outline;
  
        outline->flags &= ~FT_OUTLINE_OWNER;
        outline->flags |= FT_OUTLINE_REVERSE_FILL;
  
        if ( size && size->root.metrics.y_ppem < 24 )
          outline->flags |= FT_OUTLINE_HIGH_PRECISION;
  
        /* compute the advance vector */
        metrics->horiAdvance = 0;
        metrics->vertAdvance = 0;
  
        advance    = gchar->advance;
        em_metrics = face->phy_font.metrics_resolution;
        em_outline = face->phy_font.outline_resolution;
  
        if ( em_metrics != em_outline )
          advance = FT_MulDiv( advance, em_outline, em_metrics );
  
        if ( face->phy_font.flags & PFR_PHY_VERTICAL )
          metrics->vertAdvance = advance;
        else
          metrics->horiAdvance = advance;
  
        slot->root.linearHoriAdvance = metrics->horiAdvance;
        slot->root.linearVertAdvance = metrics->vertAdvance;
  
        /* make-up vertical metrics(?) */
        metrics->vertBearingX = 0;
        metrics->vertBearingY = 0;
  
        /* Apply the font matrix, if any.                 */
        /* TODO: Test existing fonts with unusual matrix  */
        /* whether we have to adjust Units per EM.        */
        {
          FT_Matrix font_matrix;
  
  
          font_matrix.xx = face->log_font.matrix[0] << 8;
          font_matrix.yx = face->log_font.matrix[1] << 8;
          font_matrix.xy = face->log_font.matrix[2] << 8;
          font_matrix.yy = face->log_font.matrix[3] << 8;
  
          FT_Outline_Transform( outline, &font_matrix );
        }
  
        /* scale when needed */
        if ( scaling )
        {
          FT_Int      n;
          FT_Fixed    x_scale = size->root.metrics.x_scale;
          FT_Fixed    y_scale = size->root.metrics.y_scale;
          FT_Vector*  vec     = outline->points;
  
  
          /* scale outline points */
          for ( n = 0; n < outline->n_points; n++, vec++ )
          {
            vec->x = FT_MulFix( vec->x, x_scale );
            vec->y = FT_MulFix( vec->y, y_scale );
          }
  
          /* scale the advance */
          metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
          metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
        }
  
        /* compute the rest of the metrics */
        FT_Outline_Get_CBox( outline, &cbox );
  
        metrics->width        = cbox.xMax - cbox.xMin;
        metrics->height       = cbox.yMax - cbox.yMin;
        metrics->horiBearingX = cbox.xMin;
        metrics->horiBearingY = cbox.yMax - metrics->height;
      }
  
    Exit:
      return error;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                      KERNING METHOD                           *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
    FT_LOCAL_DEF( void )
    pfr_face_get_kerning( PFR_Face    face,
                          FT_UInt     glyph1,
                          FT_UInt     glyph2,
                          FT_Vector*  kerning )
    {
      FT_Error      error    = PFR_Err_Ok;
      PFR_PhyFont   phy_font = &face->phy_font;
      PFR_KernItem  item     = phy_font->kern_items;
      FT_UInt32     idx      = PFR_KERN_INDEX( glyph1, glyph2 );
  
      FT_UNUSED( error ); /* just needed as syntactical sugar */
  
  
      kerning->x = 0;
      kerning->y = 0;
  
      /* find the kerning item containing our pair */
      while ( item )
      {
        if ( item->pair1 <= idx && idx <= item->pair2 )
          goto Found_Item;
  
        item = item->next;
      }
  
      /* not found */
      return;
  
    Found_Item:
      {
        /* perform simply binary search within the item */
        FT_UInt    min, mid, max;
        FT_Stream  stream = face->root.stream;
        FT_Byte*   p;
  
  
        if ( FT_STREAM_SEEK( item->offset )                       ||
             FT_FRAME_ENTER( item->pair_count * item->pair_size ) )
          return;
  
        min = 0;
        max = item->pair_count;
        while ( min < max )
        {
          FT_UInt  char1, char2, charcode;
  
  
          mid = ( min + max ) >> 1;
          p   = stream->cursor + mid*item->pair_size;
  
          if ( item->flags & PFR_KERN_2BYTE_CHAR )
          {
            char1 = FT_NEXT_USHORT( p );
            char2 = FT_NEXT_USHORT( p );
          }
          else
          {
            char1 = FT_NEXT_USHORT( p );
            char2 = FT_NEXT_USHORT( p );
          }
          charcode = PFR_KERN_INDEX( char1, char2 );
  
          if ( idx == charcode )
          {
            if ( item->flags & PFR_KERN_2BYTE_ADJ )
              kerning->x = item->base_adj + FT_NEXT_SHORT( p );
            else
              kerning->x = item->base_adj + FT_NEXT_CHAR( p );
  
            break;
          }
          if ( idx > charcode )
            min = mid + 1;
          else
            max = mid;
        }
  
        FT_FRAME_EXIT();
      }
    }
  
  
  /* END */
  

Download