kc3-lang/freetype/src/otlayout/oltypes.c

• Show log

  Commit

• Hash : e49ab25c
  Author :
  Date : 2000-05-16T23:44:38
  

  formatting - removed trailing spaces

Download

• src/otlayout/oltypes.c

• #include <oltypes.h>
  
    LOCAL_FUNC
    TT_Error  OTL_Table_Init( OTL_Table*  table,
                              FT_Memory   memory )
    {
      MEM_Set( table, 0, sizeof(*table) );
      table->memory = memory;
    }
  
   /* read a script list table */
   /* use with any table       */
    LOCAL_FUNC
    TT_Error  OTL_Table_Set_Scripts( OTL_Table*  table,
                                     TT_Byte*    bytes,
                                     TT_Long     len,
                                     OTL_Type    otl_type )
    {
      TT_Byte*  p;
      TT_Byte*  start = bytes;
      TT_UInt   count, max_langs;
      TT_Error  error;
  
      /* skip version of the JSTF table */
      if (otl_type == otl_jstf)
        start += 4;
  
      p = start;
  
      /* we must allocate the script_tags and language_tags arrays     */
      /* this requires that we compute the maximum number of languages */
      /* per script..                                                  */
  
      count     = table->num_scripts = OTL_UShort(p);
      max_langs = 0;
      for ( ; count > 0; count++ )
      {
        TT_Byte*  script;
        TT_UInt   num_langs;
  
        p += 4; /* skip tag */
        script = bytes + OTL_UShort(p);
  
        /* skip the baseValues or extenders field of the BASE and JSTF table */
        if (otl_type == otl_type_base || otl_type == otl_type_jstf)
          script += 2;
  
        /* test if there is a default language system */
        if ( OTL_UShort(script) )
          num_langs++;
  
        /* test other language systems */
        num_langs += OTL_UShort(script); /* add other lang sys */
  
        if (num_langs > max_langs)
          max_langs = num_langs;
      }
  
      /* good, now allocate the tag arrays */
      if ( !ALLOC_ARRAY( table->script_tags,
                        table->num_scripts + max_langs,
                        TT_ULong ) )
      {
        table->language_tags = table->script_tags + table->num_scripts;
        table->max_languages = max_langs;
        table->num_languages = 0;
        table->otl_type      = otl_type;
  
        table->scripts_table = bytes;
        table->scripts_len   = len;
  
        /* fill the script_tags array */
        {
          TT_UInt  n;
          TT_Byte* p = start + 2; /* skip count */
  
          for ( n = 0; n < table->num_scripts; n++ )
          {
            table->script_tags[n] = OTL_ULong(p);
            p += 2; /* skip offset */
          }
        }
      }
      return error;
    }
  
  
  
   /* add a features list to the table   */
   /* use only with a GSUB or GPOS table */
    LOCAL_FUNC
    TT_Error  OTL_Table_Set_Features( OTL_Table*  table,
                                      TT_Byte*    bytes,
                                      TT_Long     len )
    {
      TT_Error  error;
      TT_Byte*  p = bytes;
      TT_UInt   count;
  
      table->max_features = count = OTL_UShort(p);
      if ( !ALLOC_ARRAY( table->feature_tags, count, TT_ULong ) &&
           !ALLOC_ARRAY( table->features,     count, TT_Bool  ) )
      {
        table->features_table = bytes;
        table->features_len   = len;
      }
      return error;
    }
  
  
   /* add a lookup list to the table     */
   /* use only with a GSUB or GPOS table */
    LOCAL_FUNC
    TT_Error  OTL_Table_Set_Lookups( OTL_Table*  table,
                                     TT_Byte*    bytes,
                                     TT_Long     len )
    {
      TT_Error  error;
      TT_Byte*  p = bytes;
      TT_UInt   count;
  
      table->max_lookups = count = OTL_UShort(p);
      if ( !ALLOC_ARRAY( table->lookups, count, TT_Bool ) )
      {
        table->lookups_table = bytes;
        table->lookups_len   = len;
      }
      return error;
    }
  
   /* discard table arrays */
    LOCAL_FUNC
    void      OTL_Table_Done( OTL_Table*  table )
    {
      FREE( table->scrip_tags );
      FREE( table->language_tags );
      FREE( table->feature_tags );
      FREE( table->lookups );
    }
  
  
   /* return the list of available languages for a given script */
   /* use with any table..                                      */
    LOCAL_FUNC
    void  OTL_Get_Languages_List( OTL_Table*  table,
                                  TT_ULong    script_tag )
    {
      TT_UInt  n;
      TT_Byte* p;
      TT_Byte* script = 0;
      TT_Byte* start = table->scripts_table;
  
      if ( table->otl_type == otl_type_jstf )  /* skip version for JSTF */
        start += 4;
  
      p = start + 6; /* skip count+first tag */
  
      for ( n = 0; n < table->num_scripts; n++, p += 6 )
      {
        if ( table->script_tags[n] == script_tag )
        {
          script = table->scripts_table + OTL_UShort(p);
          break;
        }
      }
  
      table->cur_script = script;
      if (!script)
        table->num_languages = 0;
      else
      {
        /* now fill the language_tags array with the appropriate values    */
        /* not that we put a '0' tag in front of the list to indicate that */
        /* there is a default language for this script..                   */
        TT_ULong* tags = table->language_tags;
  
        switch (table->otl_type)
        {
          case otl_type_base:
          case otl_type_jstf:
            script += 2;    /* skip basevalue or extenders */
            /* fall-through */
  
          default:
            if ( OTL_UShort(script) )
              *tags++ = 0;
        }
  
        count = OTL_UShort(script);
        for ( ; count > 0; count-- )
        {
          *tags++ = OTL_ULong(script);
          script += 2; /* skip offset */
        }
  
        table->num_langs = tags - table->language_tags;
      }
    }
  
  
   /* return the list of available features for the current script/language */
   /* use with a GPOS or GSUB script table                                  */
    LOCAL_FUNC
    void OTL_Get_Features_List( OTL_Table*  table,
                                TT_ULong    language_tag )
    {
      TT_UInt   n;
      TT_Byte*  script   = table->cur_script;
      TT_Byte*  language = 0;
      TT_UShort offset;
  
      /* clear feature selection table */
      for ( n = 0; n < table->max_features; n++ )
        table->features[n] = 0;
  
      /* now, look for the current language */
      if ( language_tag == 0 )
      {
        offset = OTL_UShort(script);
        if (!offset) return; /* if there is no default language, exit */
  
        language = script - 2 + offset;
      }
      else
      {
        TT_Byte*  p = script + 8; /* skip default+count+1st tag */
        TT_UShort index;
  
        for ( n = 0; n < table->num_languages; n++, p+=6 )
        {
          if ( table->language_tags[n] == language_tag )
          {
            language = script + OTL_UShort(p);
            break;
          }
        }
  
        table->cur_language = language;
        if (!language) return;
  
        p     = language + 2;   /* skip lookup order */
        index = OTL_UShort(p);  /* required feature index */
        if (index != 0xFFFF)
        {
          if (index < table->max_features)
            table->features[index] = 1;
        }
  
        count = OTL_UShort(p);
        for ( ; count > 0; count-- )
        {
          index = OTL_UShort(p);
          if (index < table->max_features)
            table->features[index] = 1;
        }
      }
    }
  
  
   /* return the list of lookups for the current features list */
   /* use only with a GSUB or GPOS table                       */
    LOCAL_FUNC
    void  OTL_Get_Lookups_List( OTL_Table*  table )
    {
      TT_UInt  n;
      TT_Byte* features = table->features_table;
      TT_Byte* p        = features + 6; /* skip count+1st tag */
  
      /* clear lookup list */
      for ( n = 0; n < table->max_lookups; n++ )
        table->lookups[n] = 0;
  
      /* now, parse the features list */
      for ( n = 0; n < table->features; n++ )
      {
        if (table->features[n])
        {
          TT_UInt   count;
          TT_UShort index;
          TT_Byte*  feature;
  
          feature = features + OTL_UShort(p);
          p      += 4;  /* skip tag */
  
          /* now, select all lookups from this feature */
          count = OTL_UShort(feature);
          for ( ; count > 0; count-- )
          {
            index = OTL_UShort(feature);
            if (index < table->max_lookups)
              table->lookups[index] = 1;
          }
        }
      }
    }
  
  
   /* find the basevalues and minmax for the current script/language */
   /* only use it with a BASE table..                                */
    LOCAL_FUNC
    void OTL_Get_Baseline_Values( OTL_Table*  table,
                                  TT_ULong    language_tag )
    {
      TT_Byte*  script   = table->cur_script;
      TT_Byte*  p        = script;
      TT_UShort offset, count;
  
      table->cur_basevalues = 0;
      table->cur_minmax     = 0;
  
      /* read basevalues */
      offset = OTL_UShort(p);
      if (offset)
        table->cur_basevalues = script + offset;
  
      offset = OTL_UShort(p);
      if (offset)
        table->cur_minmax = script + offset;
  
      count = OTL_UShort(p);
      for ( ; count > 0; count-- )
      {
        TT_ULong  tag;
  
        tag = OTL_ULong(p);
        if ( language_tag == tag )
        {
          table->cur_minmax = script + OTL_UShort(p);
          break;
        }
        p += 2; /* skip offset */
      }
    }
  
  
   /* compute the coverage value of a given glyph id */
    LOCAL_FUNC
    TT_Long  OTL_Get_Coverage_Index( TT_Byte*  coverage,
                                     TT_UInt   glyph_id )
    {
      TT_Long    result = -1;
      TT_UInt    count, index, start, end;
      TT_Byte*   p = coverage;
  
      switch ( OTL_UShort(p) )
      {
        case 1:  /* coverage format 1 - array of glyph indices */
          {
            count = OTL_UShort(p);
            for ( index = 0; index < count; index++ )
            {
              if ( OTL_UShort(p) == glyph_id )
              {
                result = index;
                break;
              }
            }
          }
          break;
  
        case 2:
          {
            count = OTL_UShort(p);
            for ( ; count > 0; count-- )
            {
              start = OTL_UShort(p);
              end   = OTL_UShort(p);
              index = OTL_UShort(p);
              if (start <= glyph_id && glyph_id <= end)
              {
                result = glyph_id - start + index;
                break;
              }
            }
          }
          break;
      }
      return result;
    }
  
  
   /* compute the class value of a given glyph_id */
    LOCAL_FUNC
    TT_UInt  OTL_Get_Glyph_Class( TT_Byte*  class_def,
                                  TT_UInt   glyph_id )
    {
      TT_Byte*  p = class_def;
      TT_UInt   result = 0;
      TT_UInt   start, end, count, index;
  
      switch ( OTL_UShort(p) )
      {
        case 1:
          {
            start = OTL_UShort(p);
            count = OTL_UShort(p);
  
            glyph_id -= start;
            if (glyph_id < count)
            {
              p += 2*glyph_id;
              result = OTL_UShort(p);
            }
          }
          break;
  
        case 2:
          {
            count = OTL_UShort(p);
            for ( ; count > 0; count-- )
            {
              start = OTL_UShort(p);
              end   = OTL_UShort(p);
              index = OTL_UShort(p);
              if ( start <= glyph_id && glyph_id <= end )
              {
                result = index;
                break;
              }
            }
          }
          break;
      }
      return result;
    }
  
  
   /* compute the adjustement necessary for a given device size */
    LOCAL_FUNC
    TT_Int  OTL_Get_Device_Adjustment( TT_Byte* device,
                                       TT_UInt  size )
    {
      TT_Byte*  p = device;
      TT_Int    result = 0;
      TT_UInt   start, end;
      TT_Short  value;
  
      start = OTL_UShort(p);
      end   = OTL_UShort(p);
      if (size >= start && size <= end)
      {
        /* I know we could do all of this without a switch, with */
        /* clever shifts and everything, but it makes the code   */
        /* really difficult to understand..                      */
  
        size -= start;
        switch ( OTL_UShort(p) )
        {
          case 1: /* 2-bits per value */
            {
              p     += 2*(size >> 3);
              size   = (size & 7) << 1;
              value  = (TT_Short)((TT_Short)OTL_UShort(p) << size);
              result = value >> 14;
            }
            break;
  
          case 2: /* 4-bits per value */
            {
              p     += 2*(size >> 2);
              size   = (size & 3) << 2;
              value  = (TT_Short)((TT_Short)OTL_UShort(p) << size);
              result = value >> 12;
            }
            break;
  
          case 3: /* 8-bits per value */
            {
              p     += 2*(size >> 1);
              size   = (size & 1) << 3;
              value  = (TT_Short)((TT_Short)OTL_UShort(p) << size);
              result = value >> 8;
            }
            break;
        }
      }
      return result;
    }
  
   /* extract a BaseCoord value */
    LOCAL_FUNC
    void    OTL_Get_Base_Coordinate( TT_Byte*          base_coord,
                                     OTL_ValueRecord*  coord )
    {
      TT_Byte*  p = base_coord;
      TT_Int    result = 0;
  
      coord->format     = OTL_UShort(p);
      coord->coordinate = OTL_Short(p);
      coord->device     = 0;
  
      switch (coord->format)
      {
        case 2: /* format 2 */
          coord->ref_glyph = OTL_UShort(p);
          coord->ref_point = OTL_UShort(p);
          break;
  
        case 3: /* format 3 */
          coord->device = p - 4 + OTL_UShort(p);
          break;
  
        default:
          ;
      }
    }
  
  
   /* compute size of ValueRecord */
   LOCAL_FUNC
   TT_Int  OTL_ValueRecord_Size( TT_UShort  format )
   {
     TT_Int  count;
  
     /* each bit in the value format corresponds to a single ushort */
     /* we thus count the bits, and multiply the result by 2        */
  
     count = (TT_Int)(format & 0xFF);
     count = ((count & 0xAA) >> 1) + (count & 0x55);
     count = ((count & 0xCC) >> 2) + (count & 0x33);
     count = ((count & 0xF0) >> 4) + (count & 0x0F);
  
     return count*2;
   }
  
  
  
   /* extract ValueRecord */
   LOCAL_FUNC
   void  OTL_Get_ValueRecord( TT_Byte*          value_record,
                              TT_UShort         value_format,
  			    TT_Byte*          pos_table,
  			    OTL_ValueRecord*  record )
   {
     TT_Byte*  p = value_record;
  
     /* clear vectors */
     record->placement.x = 0;
     record->placement.y = 0;
     record->advance.x   = 0;
     record->advance.y   = 0;
  
     record->device_pla_x = 0;
     record->device_pla_y = 0;
     record->device_adv_x = 0;
     record->device_adv_y = 0;
  
     if (value_format & 1) record->placement.x = NEXT_Short(p);
     if (value_format & 2) record->placement.y = NEXT_Short(p);
     if (value_format & 4) record->advance.x   = NEXT_Short(p);
     if (value_format & 8) record->advance.y   = NEXT_Short(p);
  
     if (value_format & 16)  record->device_pla_x = pos_table + NEXT_UShort(p);
     if (value_format & 32)  record->device_pla_y = pos_table + NEXT_UShort(p);
     if (value_format & 64)  record->device_adv_x = pos_table + NEXT_UShort(p);
     if (value_format & 128) record->device_adv_y = pos_table + NEXT_UShort(p);
   }
  
  
  
   /* extract Anchor */
   LOCAL_FUNC
   void  OTL_Get_Anchor( TT_Byte*     anchor_table,
                         OTL_Anchor*  anchor )
   {
     TT_Byte*  p = anchor_table;
  
     anchor->format   = NEXT_UShort(p);
     anchor->coord.x  = NEXT_Short(p);
     anchor->coord.y  = NEXT_Short(p);
     anchor->point    = 0;
     anchor->device_x = 0;
     anchor->device_y = 0;
  
     switch (anchor->format)
     {
       case 2:
         anchor->point = NEXT_UShort(p);
         break;
  
       case 3:
         anchor->device_x = anchor_table + NEXT_UShort(p);
         anchor->device_y = anchor_table + NEXT_UShort(p);
         break;
  
       default:
         ;
     }
   }
  
  
  
   /* extract Mark from MarkArray */
   LOCAL_FUNC
   void  OTL_Get_Mark( TT_Byte*     mark_array,
                       TT_UInt      index,
  		     TT_UShort*   clazz,
  		     OTL_Anchor*  anchor )
   {
     TT_Byte* p = mark_array;
     TT_UInt  count;
  
     *clazz = 0;
     MEM_Set( anchor, 0, sizeof(*anchor) );
  
     count = NEXT_UShort(p);
     if (index < count)
     {
       p += 4*index;
       *clazz = NEXT_UShort(p);
       OTL_Get_Anchor( mark_array + NEXT_UShort(p), anchor );
     }
   }
  
  

Download