kc3-lang/freetype/src/type1/t1afm.c

• Show log

  Commit

• Hash : 5a73d8d2
  Author :
  Date : 2006-03-20T16:55:32
  

  * builds/freetype.mk (CACHE_DIR, CACHE_H): Remove. (FREETYPE_H): Updated. * src/cache/rules.mk (CACHE_H_DIR): Remove. (CACHE_DRV_H): Updated. Formatting, copyright years.

Download

• src/type1/t1afm.c

• /***************************************************************************/
  /*                                                                         */
  /*  t1afm.c                                                                */
  /*                                                                         */
  /*    AFM support for Type 1 fonts (body).                                 */
  /*                                                                         */
  /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 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 <ft2build.h>
  #include "t1afm.h"
  #include "t1errors.h"
  #include FT_INTERNAL_STREAM_H
  #include FT_INTERNAL_POSTSCRIPT_AUX_H
  
  
    /*************************************************************************/
    /*                                                                       */
    /* 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  */
    /* messages during execution.                                            */
    /*                                                                       */
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_t1afm
  
  
    FT_LOCAL_DEF( void )
    T1_Done_Metrics( FT_Memory     memory,
                     AFM_FontInfo  fi )
    {
      FT_FREE( fi->KernPairs );
      fi->NumKernPair = 0;
  
      FT_FREE( fi->TrackKerns );
      fi->NumTrackKern = 0;
  
      FT_FREE( fi );
    }
  
  
    /* read a glyph name and return the equivalent glyph index */
    static FT_Int
    t1_get_index( const char*  name,
                  FT_UInt      len,
                  void*        user_data )
    {
      T1_Font  type1 = (T1_Font)user_data;
      FT_Int   n;
  
  
      for ( n = 0; n < type1->num_glyphs; n++ )
      {
        char*  gname = (char*)type1->glyph_names[n];
  
  
        if ( gname && gname[0] == name[0]        &&
             ft_strlen( gname ) == len           &&
             ft_strncmp( gname, name, len ) == 0 )
          return n;
      }
  
      return 0;
    }
  
  
  #undef  KERN_INDEX
  #define KERN_INDEX( g1, g2 )  ( ( (FT_ULong)g1 << 16 ) | g2 )
  
  
    /* compare two kerning pairs */
    FT_CALLBACK_DEF( int )
    compare_kern_pairs( const void*  a,
                        const void*  b )
    {
      AFM_KernPair  pair1 = (AFM_KernPair)a;
      AFM_KernPair  pair2 = (AFM_KernPair)b;
  
      FT_ULong  index1 = KERN_INDEX( pair1->index1, pair1->index2 );
      FT_ULong  index2 = KERN_INDEX( pair2->index1, pair2->index2 );
  
  
      return (int)( index1 - index2 );
    }
  
  
    /* parse a PFM file -- for now, only read the kerning pairs */
    static FT_Error
    T1_Read_PFM( FT_Face       t1_face,
                 FT_Stream     stream,
                 AFM_FontInfo  fi )
    {
      FT_Error      error = T1_Err_Ok;
      FT_Memory     memory = stream->memory;
      FT_Byte*      start;
      FT_Byte*      limit;
      FT_Byte*      p;
      AFM_KernPair  kp;
      FT_Int        width_table_length;
      FT_CharMap    oldcharmap;
      FT_CharMap    charmap;
      FT_Int        n;
  
  
      start = (FT_Byte*)stream->cursor;
      limit = (FT_Byte*)stream->limit;
      p     = start;
  
      /* Figure out how long the width table is.          */
      /* This info is a little-endian short at offset 99. */
      p = start + 99;
      if ( p + 2 > limit )
      {
        error = T1_Err_Unknown_File_Format;
        goto Exit;
      }
      width_table_length = FT_PEEK_USHORT_LE( p );
  
      p += 18 + width_table_length;
      if ( p + 0x12 > limit || FT_PEEK_USHORT_LE( p ) < 0x12 )
        /* extension table is probably optional */
        goto Exit;
  
      /* Kerning offset is 14 bytes from start of extensions table. */
      p += 14;
      p = start + FT_PEEK_ULONG_LE( p );
  
      if ( p == start )
        /* zero offset means no table */
        goto Exit;
  
      if ( p + 2 > limit )
      {
        error = T1_Err_Unknown_File_Format;
        goto Exit;
      }
  
      fi->NumKernPair = FT_PEEK_USHORT_LE( p );
      p += 2;
      if ( p + 4 * fi->NumKernPair > limit )
      {
        error = T1_Err_Unknown_File_Format;
        goto Exit;
      }
  
      /* Actually, kerning pairs are simply optional! */
      if ( fi->NumKernPair == 0 )
        goto Exit;
  
      /* allocate the pairs */
      if ( FT_QNEW_ARRAY( fi->KernPairs, fi->NumKernPair ) )
        goto Exit;
  
      /* now, read each kern pair */
      kp             = fi->KernPairs;
      limit          = p + 4 * fi->NumKernPair;
  
      /* PFM kerning data are stored by encoding rather than glyph index, */
      /* so find the PostScript charmap of this font and install it       */
      /* temporarily.  If we find no PostScript charmap, then just use    */
      /* the default and hope it is the right one.                        */
      oldcharmap = t1_face->charmap;
      charmap    = NULL;
  
      for ( n = 0; n < t1_face->num_charmaps; n++ )
      {
        charmap = t1_face->charmaps[n];
        /* check against PostScript pseudo platform */
        if ( charmap->platform_id == 7 )
        {
          error = FT_Set_Charmap( t1_face, charmap );
          if ( error )
            goto Exit;
          break;
        }
      }
  
      /* Kerning info is stored as:             */
      /*                                        */
      /*   encoding of first glyph (1 byte)     */
      /*   encoding of second glyph (1 byte)    */
      /*   offset (little-endian short)         */
      for ( ; p < limit ; p += 4 )
      {
        kp->index1 = FT_Get_Char_Index( t1_face, p[0] );
        kp->index2 = FT_Get_Char_Index( t1_face, p[1] );
  
        kp->x = (FT_Int)FT_PEEK_USHORT_LE(p + 2);
        kp->y = 0;
  
        kp++;
      }
  
      if ( oldcharmap != NULL )
        error = FT_Set_Charmap( t1_face, oldcharmap );
      if ( error )
        goto Exit;
  
      /* now, sort the kern pairs according to their glyph indices */
      ft_qsort( fi->KernPairs, fi->NumKernPair, sizeof ( AFM_KernPairRec ),
                compare_kern_pairs );
  
    Exit:
      if ( error )
      {
        FT_FREE( fi->KernPairs );
        fi->NumKernPair = 0;
      }
  
      return error;
    }
  
  
    /* parse a metrics file -- either AFM or PFM depending on what */
    /* it turns out to be                                          */
    FT_LOCAL_DEF( FT_Error )
    T1_Read_Metrics( FT_Face    t1_face,
                     FT_Stream  stream )
    {
      PSAux_Service  psaux;
      FT_Memory      memory = stream->memory;
      AFM_ParserRec  parser;
      AFM_FontInfo   fi;
      FT_Error       error = T1_Err_Unknown_File_Format;
      T1_Font        t1_font = &( (T1_Face)t1_face )->type1;
  
  
      if ( FT_NEW( fi ) )
        return error;
  
      if ( FT_FRAME_ENTER( stream->size ) )
      {
        FT_FREE( fi );
        return error;
      }
  
      fi->FontBBox  = t1_font->font_bbox;
      fi->Ascender  = t1_font->font_bbox.yMax;
      fi->Descender = t1_font->font_bbox.yMin;
  
      psaux = (PSAux_Service)( (T1_Face)t1_face )->psaux;
      if ( psaux && psaux->afm_parser_funcs )
      {
        error = psaux->afm_parser_funcs->init( &parser,
                                               stream->memory,
                                               stream->cursor,
                                               stream->limit );
  
        if ( !error )
        {
          parser.FontInfo  = fi;
          parser.get_index = t1_get_index;
          parser.user_data = t1_font;
  
          error = psaux->afm_parser_funcs->parse( &parser );
          psaux->afm_parser_funcs->done( &parser );
        }
      }
  
      if ( error == T1_Err_Unknown_File_Format )
      {
        FT_Byte*  start = stream->cursor;
  
  
        if ( stream->size > 6                              &&
             start[0] == 0x00 && start[1] == 0x01          &&
             FT_PEEK_ULONG_LE( start + 2 ) == stream->size )
          error = T1_Read_PFM( t1_face, stream, fi );
      }
  
      if ( !error )
      {
        t1_font->font_bbox = fi->FontBBox;
  
        t1_face->bbox.xMin =   fi->FontBBox.xMin             >> 16;
        t1_face->bbox.yMin =   fi->FontBBox.yMin             >> 16;
        t1_face->bbox.xMax = ( fi->FontBBox.xMax + 0xFFFFU ) >> 16;
        t1_face->bbox.yMax = ( fi->FontBBox.yMax + 0xFFFFU ) >> 16;
  
        t1_face->ascender  = (FT_Short)( ( fi->Ascender  + 0x8000U ) >> 16 );
        t1_face->descender = (FT_Short)( ( fi->Descender + 0x8000U ) >> 16 );
  
        if ( fi->NumKernPair )
        {
          t1_face->face_flags |= FT_FACE_FLAG_KERNING;
          ( (T1_Face)t1_face )->afm_data = fi;
        }
      }
  
      FT_FRAME_EXIT();
  
      return error;
    }
  
  
    /* find the kerning for a given glyph pair */
    FT_LOCAL_DEF( void )
    T1_Get_Kerning( AFM_FontInfo  fi,
                    FT_UInt       glyph1,
                    FT_UInt       glyph2,
                    FT_Vector*    kerning )
    {
      AFM_KernPair  min, mid, max;
      FT_ULong      idx = KERN_INDEX( glyph1, glyph2 );
  
  
      /* simple binary search */
      min = fi->KernPairs;
      max = min + fi->NumKernPair - 1;
  
      while ( min <= max )
      {
        FT_ULong  midi;
  
  
        mid  = min + ( max - min ) / 2;
        midi = KERN_INDEX( mid->index1, mid->index2 );
  
        if ( midi == idx )
        {
          kerning->x = mid->x;
          kerning->y = mid->y;
  
          return;
        }
  
        if ( midi < idx )
          min = mid + 1;
        else
          max = mid - 1;
      }
  
      kerning->x = 0;
      kerning->y = 0;
    }
  
  
    FT_LOCAL_DEF( FT_Error )
    T1_Get_Track_Kerning( FT_Face    face,
                          FT_Fixed   ptsize,
                          FT_Int     degree,
                          FT_Fixed*  kerning )
    {
      AFM_FontInfo  fi = (AFM_FontInfo)( (T1_Face)face )->afm_data;
      FT_Int        i;
  
  
      if ( !fi )
        return T1_Err_Invalid_Argument;
  
      for ( i = 0; i < fi->NumTrackKern; i++ )
      {
        AFM_TrackKern  tk = fi->TrackKerns + i;
  
  
        if ( tk->degree != degree )
          continue;
  
        if ( ptsize < tk->min_ptsize )
          *kerning = tk->min_kern;
        else if ( ptsize > tk->max_ptsize )
          *kerning = tk->max_kern;
        else
        {
          *kerning = FT_MulDiv( ptsize - tk->min_ptsize,
                                tk->max_kern - tk->min_kern,
                                tk->max_ptsize - tk->min_ptsize ) +
                     tk->min_kern;
        }
      }
  
      return T1_Err_Ok;
    }
  
  
  /* END */
  

Download