tor-browser

ttkern.c (7183B)

---

/****************************************************************************
*
* ttkern.c
*
*   Routines to parse and access the 'kern' table for kerning (body).
*
* Copyright (C) 1996-2025 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 <freetype/internal/ftdebug.h>
#include <freetype/internal/ftstream.h>
#include <freetype/tttags.h>
#include "ttkern.h"

#include "sferrors.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  ttkern


#undef  TT_KERN_INDEX
#define TT_KERN_INDEX( g1, g2 )  ( ( (FT_ULong)(g1) << 16 ) | (g2) )


 FT_LOCAL_DEF( FT_Error )
 tt_face_load_kern( TT_Face    face,
                    FT_Stream  stream )
 {
   FT_Error   error;
   FT_ULong   table_size;
   FT_Byte*   p;
   FT_Byte*   p_limit;
   FT_UInt    nn, num_tables;
   FT_UInt32  avail = 0, ordered = 0;


   /* the kern table is optional; exit silently if it is missing */
   error = face->goto_table( face, TTAG_kern, stream, &table_size );
   if ( error )
     goto Exit;

   if ( table_size < 4 )  /* the case of a malformed table */
   {
     FT_ERROR(( "tt_face_load_kern:"
                " kerning table is too small - ignored\n" ));
     error = FT_THROW( Table_Missing );
     goto Exit;
   }

   if ( FT_FRAME_EXTRACT( table_size, face->kern_table ) )
   {
     FT_ERROR(( "tt_face_load_kern:"
                " could not extract kerning table\n" ));
     goto Exit;
   }

   face->kern_table_size = table_size;

   p       = face->kern_table;
   p_limit = p + table_size;

   p         += 2; /* skip version */
   num_tables = FT_NEXT_USHORT( p );

   if ( num_tables > 32 ) /* we only support up to 32 sub-tables */
     num_tables = 32;

   for ( nn = 0; nn < num_tables; nn++ )
   {
     FT_UInt    num_pairs, length, coverage, format;
     FT_Byte*   p_next;
     FT_UInt32  mask = (FT_UInt32)1UL << nn;


     if ( p + 6 > p_limit )
       break;

     p_next = p;

     p       += 2; /* skip version */
     length   = FT_NEXT_USHORT( p );
     coverage = FT_NEXT_USHORT( p );

     if ( length <= 6 + 8 )
       break;

     p_next += length;

     if ( p_next > p_limit )  /* handle broken table */
       p_next = p_limit;

     format = coverage >> 8;

     /* we currently only support format 0 kerning tables */
     if ( format != 0 )
       goto NextTable;

     /* only use horizontal kerning tables */
     if ( ( coverage & 3U ) != 0x0001 ||
          p + 8 > p_next              )
       goto NextTable;

     num_pairs = FT_NEXT_USHORT( p );
     p        += 6;

     if ( ( p_next - p ) < 6 * (int)num_pairs ) /* handle broken count */
       num_pairs = (FT_UInt)( ( p_next - p ) / 6 );

     avail |= mask;

     /*
      * Now check whether the pairs in this table are ordered.
      * We then can use binary search.
      */
     if ( num_pairs > 0 )
     {
       FT_ULong  count;
       FT_ULong  old_pair;


       old_pair = FT_NEXT_ULONG( p );
       p       += 2;

       for ( count = num_pairs - 1; count > 0; count-- )
       {
         FT_UInt32  cur_pair;


         cur_pair = FT_NEXT_ULONG( p );
         if ( cur_pair < old_pair )
           break;

         p += 2;
         old_pair = cur_pair;
       }

       if ( count == 0 )
         ordered |= mask;
     }

   NextTable:
     p = p_next;
   }

   face->num_kern_tables = nn;
   face->kern_avail_bits = avail;
   face->kern_order_bits = ordered;

 Exit:
   return error;
 }


 FT_LOCAL_DEF( void )
 tt_face_done_kern( TT_Face  face )
 {
   FT_Stream  stream = face->root.stream;


   FT_FRAME_RELEASE( face->kern_table );
   face->kern_table_size = 0;
   face->num_kern_tables = 0;
   face->kern_avail_bits = 0;
   face->kern_order_bits = 0;
 }


 FT_LOCAL_DEF( FT_Int )
 tt_face_get_kerning( TT_Face  face,
                      FT_UInt  left_glyph,
                      FT_UInt  right_glyph )
 {
   FT_Int   result = 0;
   FT_UInt  count, mask;

   FT_Byte*  p;
   FT_Byte*  p_limit;


   if ( !face->kern_table )
     return result;

   p       = face->kern_table;
   p_limit = p + face->kern_table_size;

   p   += 4;
   mask = 0x0001;

   for ( count = face->num_kern_tables;
         count > 0 && p + 6 <= p_limit;
         count--, mask <<= 1 )
   {
     FT_Byte* base     = p;
     FT_Byte* next;
     FT_UInt  version  = FT_NEXT_USHORT( p );
     FT_UInt  length   = FT_NEXT_USHORT( p );
     FT_UInt  coverage = FT_NEXT_USHORT( p );
     FT_UInt  num_pairs;
     FT_Int   value    = 0;

     FT_UNUSED( version );


     next = base + length;

     if ( next > p_limit )  /* handle broken table */
       next = p_limit;

     if ( ( face->kern_avail_bits & mask ) == 0 )
       goto NextTable;

     FT_ASSERT( p + 8 <= next ); /* tested in tt_face_load_kern */

     num_pairs = FT_NEXT_USHORT( p );
     p        += 6;

     if ( ( next - p ) < 6 * (int)num_pairs )  /* handle broken count  */
       num_pairs = (FT_UInt)( ( next - p ) / 6 );

     switch ( coverage >> 8 )
     {
     case 0:
       {
         FT_ULong  key0 = TT_KERN_INDEX( left_glyph, right_glyph );


         if ( face->kern_order_bits & mask )   /* binary search */
         {
           FT_UInt   min = 0;
           FT_UInt   max = num_pairs;


           while ( min < max )
           {
             FT_UInt   mid = ( min + max ) >> 1;
             FT_Byte*  q   = p + 6 * mid;
             FT_ULong  key;


             key = FT_NEXT_ULONG( q );

             if ( key == key0 )
             {
               value = FT_PEEK_SHORT( q );
               goto Found;
             }
             if ( key < key0 )
               min = mid + 1;
             else
               max = mid;
           }
         }
         else /* linear search */
         {
           FT_UInt  count2;


           for ( count2 = num_pairs; count2 > 0; count2-- )
           {
             FT_ULong  key = FT_NEXT_ULONG( p );


             if ( key == key0 )
             {
               value = FT_PEEK_SHORT( p );
               goto Found;
             }
             p += 2;
           }
         }
       }
       break;

      /*
       * We don't support format 2 because we haven't seen a single font
       * using it in real life...
       */

     default:
       ;
     }

     goto NextTable;

   Found:
     if ( coverage & 8 ) /* override or add */
       result = value;
     else
       result += value;

   NextTable:
     p = next;
   }

   return result;
 }

#undef TT_KERN_INDEX

/* END */