src/freetype/cff/t2load.c

/***************************************************************************/
/*                                                                         */
/*  t2load.c                                                               */
/*                                                                         */
/*    TrueType glyph data/program tables loader (body).                    */
/*                                                                         */
/*  Copyright 1996-2000 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/ftobjs.h>
#include <freetype/internal/ftstream.h>
#include <freetype/internal/psnames.h>

#include <freetype/internal/t2errors.h>
#include <freetype/tttags.h>


#ifdef FT_FLAT_COMPILE

#include "t2load.h"
#include "t2parse.h"

#else

#include <cff/t2load.h>
#include <cff/t2parse.h>

#endif


  /*************************************************************************/
  /*                                                                       */
  /* 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_t2load


 /* read a CFF offset from memory */
  static
  FT_ULong  t2_get_offset( FT_Byte*  p,
                           FT_Byte   off_size )
  {
    FT_ULong  result;


    for ( result = 0; off_size > 0; off_size-- )
    {
      result <<= 8;
      result  |= *p++;
    }

    return result;
  }


  static
  FT_Error  t2_new_cff_index( CFF_Index*  index,
                              FT_Stream   stream,
                              FT_Bool     load )
  {
    FT_Error  error;
    FT_Memory memory = stream->memory;
    FT_UShort count;


    MEM_Set( index, 0, sizeof ( *index ) );

    index->stream = stream;
    if ( !READ_UShort( count ) &&
         count > 0             )
    {
      FT_Byte*   p;
      FT_Byte    offsize;
      FT_ULong   data_size;
      FT_ULong*  poff;


      /* there is at least one element; read the offset size,           */
      /* then access the offset table to compute the index's total size */
      if ( READ_Byte( offsize ) )
        goto Exit;

      index->stream   = stream;
      index->count    = count;
      index->off_size = offsize;
      data_size       = (FT_ULong)( count + 1 ) * offsize;

      if ( ALLOC_ARRAY( index->offsets, count + 1, FT_ULong ) ||
           ACCESS_Frame( data_size )                          )
        goto Exit;

      poff = index->offsets;
      p    = (FT_Byte*)stream->cursor;

      for ( ; (FT_Short)count >= 0; count-- )
      {
        poff[0] = t2_get_offset( p, offsize );
        poff++;
        p += offsize;
      }

      FORGET_Frame();

      index->data_offset = FILE_Pos();
      data_size          = poff[-1] - 1;

      if ( load )
      {
        /* load the data */
        if ( EXTRACT_Frame( data_size, index->bytes ) )
          goto Exit;
      }
      else
      {
        /* skip the data */
        (void)FILE_Skip( data_size );
      }
    }

  Exit:
    if ( error )
      FREE( index->offsets );

    return error;
  }


  static
  void  t2_done_cff_index( CFF_Index*  index )
  {
    if ( index->stream )
    {
      FT_Stream  stream = index->stream;
      FT_Memory  memory = stream->memory;


      if ( index->bytes )
        RELEASE_Frame( index->bytes );

      FREE( index->offsets );
      MEM_Set( index, 0, sizeof ( *index ) );
    }
  }


  static
  FT_Error  t2_explicit_cff_index( CFF_Index*  index,
                                   FT_Byte***  table )
  {
    FT_Error   error  = 0;
    FT_Memory  memory = index->stream->memory;
    FT_UInt    n, offset, old_offset;
    FT_Byte**  t;


    *table = 0;

    if ( index->count > 0 && !ALLOC_ARRAY( t, index->count + 1, FT_Byte* ) )
    {
      old_offset = 1;
      for ( n = 0; n <= index->count; n++ )
      {
        offset = index->offsets[n];
        if ( !offset )
          offset = old_offset;

        t[n] = index->bytes + offset - 1;

        old_offset = offset;
      }
      *table = t;
    }

    return error;
  }


  LOCAL_FUNC
  FT_Error  T2_Access_Element( CFF_Index*  index,
                               FT_UInt     element,
                               FT_Byte**   pbytes,
                               FT_ULong*   pbyte_len )
  {
    FT_Error  error = 0;


    if ( index && index->count > element )
    {
      /* compute start and end offsets */
      FT_ULong  off1, off2;


      off1 = index->offsets[element];
      if ( off1 )
      {
        do
        {
          element++;
          off2 = index->offsets[element];

        } while ( off2 == 0 && element < index->count );

        if ( !off2 )
          off1 = 0;
      }

      /* access element */
      if ( off1 )
      {
        *pbyte_len = off2 - off1;

        if ( index->bytes )
        {
          /* this index was completely loaded in memory, that's easy */
          *pbytes = index->bytes + off1 - 1;
        }
        else
        {
          /* this index is still on disk/file, access it through a frame */
          FT_Stream  stream = index->stream;


          if ( FILE_Seek( index->data_offset + off1 - 1 ) ||
               EXTRACT_Frame( off2 - off1, *pbytes )      )
            goto Exit;
        }
      }
      else
      {
        /* empty index element */
        *pbytes    = 0;
        *pbyte_len = 0;
      }
    }
    else
      error = T2_Err_Invalid_Argument;

  Exit:
    return error;
  }


  LOCAL_FUNC
  void  T2_Forget_Element( CFF_Index*  index,
                           FT_Byte**   pbytes )
  {
    if ( index->bytes == 0 )
    {
      FT_Stream  stream = index->stream;


      RELEASE_Frame( *pbytes );
    }
  }


  LOCAL_FUNC
  FT_String*  T2_Get_Name( CFF_Index*  index,
                           FT_UInt     element )
  {
    FT_Memory   memory = index->stream->memory;
    FT_Byte*    bytes;
    FT_ULong    byte_len;
    FT_Error    error;
    FT_String*  name = 0;


    error = T2_Access_Element( index, element, &bytes, &byte_len );
    if ( error )
      goto Exit;

    if ( !ALLOC( name, byte_len + 1 ) )
    {
      MEM_Copy( name, bytes, byte_len );
      name[byte_len] = 0;
    }
    T2_Forget_Element( index, &bytes );

  Exit:
    return name;
  }


  LOCAL_FUNC
  FT_String*  T2_Get_String( CFF_Index*          index,
                             FT_UInt             sid,
                             PSNames_Interface*  interface )
  {
    /* if it is not a standard string, return it */
    if ( sid > 390 )
      return T2_Get_Name( index, sid - 390 );

    /* that's a standard string, fetch a copy from the PSName module */
    {
      FT_String*   name       = 0;
      const char*  adobe_name = interface->adobe_std_strings( sid );
      FT_UInt      len;


      if ( adobe_name )
      {
        FT_Memory memory = index->stream->memory;
        FT_Error  error;


        len = (FT_UInt)strlen( adobe_name );
        if ( !ALLOC( name, len + 1 ) )
        {
          MEM_Copy( name, adobe_name, len );
          name[len] = 0;
        }
      }

      return name;
    }
  }


  /*************************************************************************/
  /*************************************************************************/
  /***                                                                   ***/
  /***   FD Select table support                                         ***/
  /***                                                                   ***/
  /*************************************************************************/
  /*************************************************************************/


  static
  void  CFF_Done_FD_Select( CFF_FD_Select*  select,
                            FT_Stream       stream )
  {
    if ( select->data )
      RELEASE_Frame( select->data );

    select->data_size   = 0;
    select->format      = 0;
    select->range_count = 0;
  }


  static
  FT_Error  CFF_Load_FD_Select( CFF_FD_Select*  select,
                                FT_UInt         num_glyphs,
                                FT_Stream       stream,
                                FT_ULong        offset )
  {
    FT_Error       error;
    FT_Byte        format;
    FT_UInt        num_ranges;


    /* read format */
    if ( FILE_Seek( offset ) || READ_Byte( format ) )
      goto Exit;

    select->format      = format;
    select->cache_count = 0;   /* clear cache */

    switch ( format )
    {
    case 0:     /* format 0, that's simple */
      select->data_size = num_glyphs;
      goto Load_Data;

    case 3:     /* format 3, a tad more complex */
      if ( READ_UShort( num_ranges ) )
        goto Exit;

      select->data_size = num_ranges * 3 + 2;

    Load_Data:
      if ( EXTRACT_Frame( select->data_size, select->data ) )
        goto Exit;
      break;

    default:    /* hmm... that's wrong */
      error = T2_Err_Invalid_File_Format;
    }

  Exit:
    return error;
  }


  LOCAL_FUNC
  FT_Byte  CFF_Get_FD( CFF_FD_Select*  select,
                       FT_UInt         glyph_index )
  {
    FT_Byte  fd = 0;


    switch ( select->format )
    {
    case 0:
      fd = select->data[glyph_index];
      break;

    case 3:
      /* first, compare to cache */
      if ( (FT_UInt)(glyph_index-select->cache_first) < select->cache_count )
      {
        fd = select->cache_fd;
        break;
      }

      /* then, lookup the ranges array */
      {
        FT_Byte*  p       = select->data;
        FT_Byte*  p_limit = p + select->data_size;
        FT_Byte   fd2;
        FT_UInt   first, limit;


        first = NEXT_UShort( p );
        do
        {
          if ( glyph_index < first )
            break;

          fd2   = *p++;
          limit = NEXT_UShort( p );

          if ( glyph_index < limit )
          {
            fd = fd2;

            /* update cache */
            select->cache_first = first;
            select->cache_count = limit-first;
            select->cache_fd    = fd2;
            break;
          }
          first = limit;

        } while ( p < p_limit );
      }
      break;

    default:
      ;
    }

    return fd;
  }


  /*************************************************************************/
  /*************************************************************************/
  /***                                                                   ***/
  /***   CFF font support                                                ***/
  /***                                                                   ***/
  /*************************************************************************/
  /*************************************************************************/


  static
  FT_Error  CFF_Load_SubFont( CFF_SubFont*  font,
                              CFF_Index*    index,
                              FT_UInt       font_index,
                              FT_Stream     stream,
                              FT_ULong      base_offset )
  {
    FT_Error        error;
    T2_Parser       parser;
    FT_Byte*        dict;
    FT_ULong        dict_len;
    CFF_Font_Dict*  top  = &font->font_dict;
    CFF_Private*    priv = &font->private_dict;


    T2_Parser_Init( &parser, T2CODE_TOPDICT, &font->font_dict );

    /* set defaults */
    MEM_Set( top, 0, sizeof ( *top ) );

    top->underline_position  = -100;
    top->underline_thickness = 50;
    top->charstring_type     = 2;
    top->font_matrix.xx      = 0x10000L;
    top->font_matrix.yy      = 0x10000L;
    top->cid_count           = 8720;

    error = T2_Access_Element( index, font_index, &dict, &dict_len ) ||
            T2_Parser_Run( &parser, dict, dict + dict_len );

    T2_Forget_Element( index, &dict );

    if ( error )
      goto Exit;

    /* if it is a CID font, we stop there */
    if ( top->cid_registry )
      goto Exit;

    /* parse the private dictionary, if any */
    if ( top->private_offset && top->private_size )
    {
      /* set defaults */
      MEM_Set( priv, 0, sizeof ( *priv ) );

      priv->blue_shift       = 7;
      priv->blue_fuzz        = 1;
      priv->lenIV            = -1;
      priv->expansion_factor = (FT_Fixed)0.06 * 0x10000L;
      priv->blue_scale       = (FT_Fixed)0.039625 * 0x10000L;

      T2_Parser_Init( &parser, T2CODE_PRIVATE, priv );

      if ( FILE_Seek( base_offset + font->font_dict.private_offset ) ||
           ACCESS_Frame( font->font_dict.private_size )              )
        goto Exit;

      error = T2_Parser_Run( &parser,
                             (FT_Byte*)stream->cursor,
                             (FT_Byte*)stream->limit );
      FORGET_Frame();
      if ( error )
        goto Exit;
    }

    /* read the local subrs, if any */
    if ( priv->local_subrs_offset )
    {
      if ( FILE_Seek( base_offset + top->private_offset +
                      priv->local_subrs_offset ) )
        goto Exit;

      error = t2_new_cff_index( &font->local_subrs_index, stream, 1 );
      if ( error )
        goto Exit;

      font->num_local_subrs = font->local_subrs_index.count;
      error = t2_explicit_cff_index( &font->local_subrs_index,
                                     &font->local_subrs );
    }

  Exit:
    return error;
  }


  static
  void  CFF_Done_SubFont( FT_Memory     memory,
                          CFF_SubFont*  subfont )
  {
    if ( subfont )
    {
      t2_done_cff_index( &subfont->local_subrs_index );
      FREE( subfont->local_subrs );
    }
  }


  LOCAL_FUNC
  FT_Error  T2_Load_CFF_Font( FT_Stream  stream,
                              FT_Int     face_index,
                              CFF_Font*  font )
  {
    static const FT_Frame_Field  cff_header_fields[] =
    {
      FT_FRAME_START( 4 ),
        FT_FRAME_BYTE( CFF_Font, version_major ),
        FT_FRAME_BYTE( CFF_Font, version_minor ),
        FT_FRAME_BYTE( CFF_Font, header_size ),
        FT_FRAME_BYTE( CFF_Font, absolute_offsize ),
      FT_FRAME_END
    };

    FT_Error        error;
    FT_Memory       memory = stream->memory;
    FT_ULong        base_offset;
    CFF_Font_Dict*  dict;


    MEM_Set( font, 0, sizeof ( *font ) );
    font->stream = stream;
    font->memory = memory;
    dict         = &font->top_font.font_dict;
    base_offset  = FILE_Pos();

    /* read CFF font header */
    if ( READ_Fields( cff_header_fields, font ) )
      goto Exit;

    /* check format */
    if ( font->version_major   != 1 ||
         font->header_size      < 4 ||
         font->absolute_offsize > 4 )
    {
      FT_TRACE2(( "[not a CFF font header!]\n" ));
      error = FT_Err_Unknown_File_Format;
      goto Exit;
    }

    /* skip the rest of the header */
    (void)FILE_Skip( font->header_size - 4 );

    /* read the name, top dict, string and global subrs index */
    error = t2_new_cff_index( &font->name_index, stream, 0 )       ||
            t2_new_cff_index( &font->font_dict_index, stream, 0 )  ||
            t2_new_cff_index( &font->string_index, stream, 0 )     ||
            t2_new_cff_index( &font->global_subrs_index, stream, 1 );
    if ( error )
      goto Exit;

    /* well, we don't really forget the `disabled' fonts... */
    font->num_faces = font->name_index.count;
    if ( face_index >= (FT_Int)font->num_faces )
    {
      FT_ERROR(( "T2_Load_CFF_Font: incorrect face index = %d\n",
                 face_index ));
      error = T2_Err_Invalid_Argument;
    }

    /* in case of a font format check, simply exit now */
    if ( face_index < 0 )
      goto Exit;

    /* now, parse the top-level font dictionary */
    error = CFF_Load_SubFont( &font->top_font,
                              &font->font_dict_index,
                              face_index,
                              stream,
                              base_offset );
    if ( error )
      goto Exit;

    /* now, check for a CID font */
    if ( dict->cid_registry )
    {
      CFF_Index     fd_index;
      CFF_SubFont*  sub;
      FT_UInt       index;


      /* this is a CID-keyed font, we must now allocate a table of */
      /* sub-fonts, then load each of them separately              */
      if ( FILE_Seek( base_offset + dict->cid_fd_array_offset ) )
        goto Exit;

      error = t2_new_cff_index( &fd_index, stream, 0 );
      if ( error )
        goto Exit;

      if ( fd_index.count > CFF_MAX_CID_FONTS )
      {
        FT_ERROR(( "T2_Load_CFF_Font: FD array too large in CID font\n" ));
        goto Fail_CID;
      }

      /* allocate & read each font dict independently */
      font->num_subfonts = fd_index.count;
      if ( ALLOC_ARRAY( sub, fd_index.count, CFF_SubFont ) )
        goto Fail_CID;

      /* setup pointer table */
      for ( index = 0; index < fd_index.count; index++ )
        font->subfonts[index] = sub + index;

      /* now load each sub font independently */
      for ( index = 0; index < fd_index.count; index++ )
      {
        sub = font->subfonts[index];
        error = CFF_Load_SubFont( sub, &fd_index, index,
                                  stream, base_offset );
        if ( error )
          goto Fail_CID;
      }

      /* now load the FD Select array */
      error = CFF_Load_FD_Select( &font->fd_select,
                                  dict->cid_count,
                                  stream,
                                  base_offset + dict->cid_fd_select_offset );

   Fail_CID:
      t2_done_cff_index( &fd_index );

      if ( error )
        goto Exit;
    }
    else
      font->num_subfonts = 0;

    /* read the charstrings index now */
    if ( dict->charstrings_offset == 0 )
    {
      FT_ERROR(( "T2_Load_CFF_Font: no charstrings offset!\n" ));
      error = FT_Err_Unknown_File_Format;
      goto Exit;
    }

    if ( FILE_Seek( base_offset + dict->charstrings_offset ) )
      goto Exit;

    error = t2_new_cff_index( &font->charstrings_index, stream, 0 );
    if ( error )
      goto Exit;

    /* explicit the global subrs */
    font->num_global_subrs = font->global_subrs_index.count;
    font->num_glyphs       = font->charstrings_index.count;

    error = t2_explicit_cff_index( &font->global_subrs_index,
                                   &font->global_subrs ) ;

    if ( error )
      goto Exit;

    /* get the font name */
    font->font_name = T2_Get_Name( &font->name_index, face_index );

  Exit:
    return error;
  }


  LOCAL_FUNC
  void  T2_Done_CFF_Font( CFF_Font*  font )
  {
    FT_Memory  memory = font->memory;
    FT_UInt    index;


    t2_done_cff_index( &font->global_subrs_index );
    t2_done_cff_index( &font->string_index );
    t2_done_cff_index( &font->font_dict_index );
    t2_done_cff_index( &font->name_index );
    t2_done_cff_index( &font->charstrings_index );

    /* release font dictionaries */
    for ( index = 0; index < font->num_subfonts; index++ )
      CFF_Done_SubFont( memory, font->subfonts[index] );

    CFF_Done_SubFont( memory, &font->top_font );

    CFF_Done_FD_Select( &font->fd_select, font->stream );

    FREE( font->global_subrs );
    FREE( font->font_name );
  }


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* t2load.c */
	4	/* */
	5	/* TrueType glyph data/program tables loader (body). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#include <freetype/internal/ftdebug.h>
	20	#include <freetype/internal/ftobjs.h>
	21	#include <freetype/internal/ftstream.h>
	22	#include <freetype/internal/psnames.h>
	23
	24	#include <freetype/internal/t2errors.h>
	25	#include <freetype/tttags.h>
	26
	27
	28	#ifdef FT_FLAT_COMPILE
	29
	30	#include "t2load.h"
	31	#include "t2parse.h"
	32
	33	#else
	34
	35	#include <cff/t2load.h>
	36	#include <cff/t2parse.h>
	37
	38	#endif
	39
	40
	41	/*************************************************************************/
	42	/* */
	43	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
	44	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
	45	/* messages during execution. */
	46	/* */
	47	#undef FT_COMPONENT
	48	#define FT_COMPONENT trace_t2load
	49
	50
	51	/* read a CFF offset from memory */
	52	static
	53	FT_ULong t2_get_offset( FT_Byte* p,
	54	FT_Byte off_size )
	55	{
	56	FT_ULong result;
	57
	58
	59	for ( result = 0; off_size > 0; off_size-- )
	60	{
	61	result <<= 8;
	62	result \|= *p++;
	63	}
	64
	65	return result;
	66	}
	67
	68
	69	static
	70	FT_Error t2_new_cff_index( CFF_Index* index,
	71	FT_Stream stream,
	72	FT_Bool load )
	73	{
	74	FT_Error error;
	75	FT_Memory memory = stream->memory;
	76	FT_UShort count;
	77
	78
	79	MEM_Set( index, 0, sizeof ( *index ) );
	80
	81	index->stream = stream;
	82	if ( !READ_UShort( count ) &&
	83	count > 0 )
	84	{
	85	FT_Byte* p;
	86	FT_Byte offsize;
	87	FT_ULong data_size;
	88	FT_ULong* poff;
	89
	90
	91	/* there is at least one element; read the offset size, */
	92	/* then access the offset table to compute the index's total size */
	93	if ( READ_Byte( offsize ) )
	94	goto Exit;
	95
	96	index->stream = stream;
	97	index->count = count;
	98	index->off_size = offsize;
	99	data_size = (FT_ULong)( count + 1 ) * offsize;
	100
	101	if ( ALLOC_ARRAY( index->offsets, count + 1, FT_ULong ) \|\|
	102	ACCESS_Frame( data_size ) )
	103	goto Exit;
	104
	105	poff = index->offsets;
	106	p = (FT_Byte*)stream->cursor;
	107
	108	for ( ; (FT_Short)count >= 0; count-- )
	109	{
	110	poff[0] = t2_get_offset( p, offsize );
	111	poff++;
	112	p += offsize;
	113	}
	114
	115	FORGET_Frame();
	116
	117	index->data_offset = FILE_Pos();
	118	data_size = poff[-1] - 1;
	119
	120	if ( load )
	121	{
	122	/* load the data */
	123	if ( EXTRACT_Frame( data_size, index->bytes ) )
	124	goto Exit;
	125	}
	126	else
	127	{
	128	/* skip the data */
	129	(void)FILE_Skip( data_size );
	130	}
	131	}
	132
	133	Exit:
	134	if ( error )
	135	FREE( index->offsets );
	136
	137	return error;
	138	}
	139
	140
	141	static
	142	void t2_done_cff_index( CFF_Index* index )
	143	{
	144	if ( index->stream )
	145	{
	146	FT_Stream stream = index->stream;
	147	FT_Memory memory = stream->memory;
	148
	149
	150	if ( index->bytes )
	151	RELEASE_Frame( index->bytes );
	152
	153	FREE( index->offsets );
	154	MEM_Set( index, 0, sizeof ( *index ) );
	155	}
	156	}
	157
	158
	159	static
	160	FT_Error t2_explicit_cff_index( CFF_Index* index,
	161	FT_Byte*** table )
	162	{
	163	FT_Error error = 0;
	164	FT_Memory memory = index->stream->memory;
	165	FT_UInt n, offset, old_offset;
	166	FT_Byte** t;
	167
	168
	169	*table = 0;
	170
	171	if ( index->count > 0 && !ALLOC_ARRAY( t, index->count + 1, FT_Byte* ) )
	172	{
	173	old_offset = 1;
	174	for ( n = 0; n <= index->count; n++ )
	175	{
	176	offset = index->offsets[n];
	177	if ( !offset )
	178	offset = old_offset;
	179
	180	t[n] = index->bytes + offset - 1;
	181
	182	old_offset = offset;
	183	}
	184	*table = t;
	185	}
	186
	187	return error;
	188	}
	189
	190
	191	LOCAL_FUNC
	192	FT_Error T2_Access_Element( CFF_Index* index,
	193	FT_UInt element,
	194	FT_Byte** pbytes,
	195	FT_ULong* pbyte_len )
	196	{
	197	FT_Error error = 0;
	198
	199
	200	if ( index && index->count > element )
	201	{
	202	/* compute start and end offsets */
	203	FT_ULong off1, off2;
	204
	205
	206	off1 = index->offsets[element];
	207	if ( off1 )
	208	{
	209	do
	210	{
	211	element++;
	212	off2 = index->offsets[element];
	213
	214	} while ( off2 == 0 && element < index->count );
	215
	216	if ( !off2 )
	217	off1 = 0;
	218	}
	219
	220	/* access element */
	221	if ( off1 )
	222	{
	223	*pbyte_len = off2 - off1;
	224
	225	if ( index->bytes )
	226	{
	227	/* this index was completely loaded in memory, that's easy */
	228	*pbytes = index->bytes + off1 - 1;
	229	}
	230	else
	231	{
	232	/* this index is still on disk/file, access it through a frame */
	233	FT_Stream stream = index->stream;
	234
	235
	236	if ( FILE_Seek( index->data_offset + off1 - 1 ) \|\|
	237	EXTRACT_Frame( off2 - off1, *pbytes ) )
	238	goto Exit;
	239	}
	240	}
	241	else
	242	{
	243	/* empty index element */
	244	*pbytes = 0;
	245	*pbyte_len = 0;
	246	}
	247	}
	248	else
	249	error = T2_Err_Invalid_Argument;
	250
	251	Exit:
	252	return error;
	253	}
	254
	255
	256	LOCAL_FUNC
	257	void T2_Forget_Element( CFF_Index* index,
	258	FT_Byte** pbytes )
	259	{
	260	if ( index->bytes == 0 )
	261	{
	262	FT_Stream stream = index->stream;
	263
	264
	265	RELEASE_Frame( *pbytes );
	266	}
	267	}
	268
	269
	270	LOCAL_FUNC
	271	FT_String* T2_Get_Name( CFF_Index* index,
	272	FT_UInt element )
	273	{
	274	FT_Memory memory = index->stream->memory;
	275	FT_Byte* bytes;
	276	FT_ULong byte_len;
	277	FT_Error error;
	278	FT_String* name = 0;
	279
	280
	281	error = T2_Access_Element( index, element, &bytes, &byte_len );
	282	if ( error )
	283	goto Exit;
	284
	285	if ( !ALLOC( name, byte_len + 1 ) )
	286	{
	287	MEM_Copy( name, bytes, byte_len );
	288	name[byte_len] = 0;
	289	}
	290	T2_Forget_Element( index, &bytes );
	291
	292	Exit:
	293	return name;
	294	}
	295
	296
	297	LOCAL_FUNC
	298	FT_String* T2_Get_String( CFF_Index* index,
	299	FT_UInt sid,
	300	PSNames_Interface* interface )
	301	{
	302	/* if it is not a standard string, return it */
	303	if ( sid > 390 )
	304	return T2_Get_Name( index, sid - 390 );
	305
	306	/* that's a standard string, fetch a copy from the PSName module */
	307	{
	308	FT_String* name = 0;
	309	const char* adobe_name = interface->adobe_std_strings( sid );
	310	FT_UInt len;
	311
	312
	313	if ( adobe_name )
	314	{
	315	FT_Memory memory = index->stream->memory;
	316	FT_Error error;
	317
	318
	319	len = (FT_UInt)strlen( adobe_name );
	320	if ( !ALLOC( name, len + 1 ) )
	321	{
	322	MEM_Copy( name, adobe_name, len );
	323	name[len] = 0;
	324	}
	325	}
	326
	327	return name;
	328	}
	329	}
	330
	331
	332	/*************************************************************************/
	333	/*************************************************************************/
	334	/* */
	335	/* FD Select table support */
	336	/* */
	337	/*************************************************************************/
	338	/*************************************************************************/
	339
	340
	341	static
	342	void CFF_Done_FD_Select( CFF_FD_Select* select,
	343	FT_Stream stream )
	344	{
	345	if ( select->data )
	346	RELEASE_Frame( select->data );
	347
	348	select->data_size = 0;
	349	select->format = 0;
	350	select->range_count = 0;
	351	}
	352
	353
	354	static
	355	FT_Error CFF_Load_FD_Select( CFF_FD_Select* select,
	356	FT_UInt num_glyphs,
	357	FT_Stream stream,
	358	FT_ULong offset )
	359	{
	360	FT_Error error;
	361	FT_Byte format;
	362	FT_UInt num_ranges;
	363
	364
	365	/* read format */
	366	if ( FILE_Seek( offset ) \|\| READ_Byte( format ) )
	367	goto Exit;
	368
	369	select->format = format;
	370	select->cache_count = 0; /* clear cache */
	371
	372	switch ( format )
	373	{
	374	case 0: /* format 0, that's simple */
	375	select->data_size = num_glyphs;
	376	goto Load_Data;
	377
	378	case 3: /* format 3, a tad more complex */
	379	if ( READ_UShort( num_ranges ) )
	380	goto Exit;
	381
	382	select->data_size = num_ranges * 3 + 2;
	383
	384	Load_Data:
	385	if ( EXTRACT_Frame( select->data_size, select->data ) )
	386	goto Exit;
	387	break;
	388
	389	default: /* hmm... that's wrong */
	390	error = T2_Err_Invalid_File_Format;
	391	}
	392
	393	Exit:
	394	return error;
	395	}
	396
	397
	398	LOCAL_FUNC
	399	FT_Byte CFF_Get_FD( CFF_FD_Select* select,
	400	FT_UInt glyph_index )
	401	{
	402	FT_Byte fd = 0;
	403
	404
	405	switch ( select->format )
	406	{
	407	case 0:
	408	fd = select->data[glyph_index];
	409	break;
	410
	411	case 3:
	412	/* first, compare to cache */
	413	if ( (FT_UInt)(glyph_index-select->cache_first) < select->cache_count )
	414	{
	415	fd = select->cache_fd;
	416	break;
	417	}
	418
	419	/* then, lookup the ranges array */
	420	{
	421	FT_Byte* p = select->data;
	422	FT_Byte* p_limit = p + select->data_size;
	423	FT_Byte fd2;
	424	FT_UInt first, limit;
	425
	426
	427	first = NEXT_UShort( p );
	428	do
	429	{
	430	if ( glyph_index < first )
	431	break;
	432
	433	fd2 = *p++;
	434	limit = NEXT_UShort( p );
	435
	436	if ( glyph_index < limit )
	437	{
	438	fd = fd2;
	439
	440	/* update cache */
	441	select->cache_first = first;
	442	select->cache_count = limit-first;
	443	select->cache_fd = fd2;
	444	break;
	445	}
	446	first = limit;
	447
	448	} while ( p < p_limit );
	449	}
	450	break;
	451
	452	default:
	453	;
	454	}
	455
	456	return fd;
	457	}
	458
	459
	460	/*************************************************************************/
	461	/*************************************************************************/
	462	/* */
	463	/* CFF font support */
	464	/* */
	465	/*************************************************************************/
	466	/*************************************************************************/
	467
	468
	469	static
	470	FT_Error CFF_Load_SubFont( CFF_SubFont* font,
	471	CFF_Index* index,
	472	FT_UInt font_index,
	473	FT_Stream stream,
	474	FT_ULong base_offset )
	475	{
	476	FT_Error error;
	477	T2_Parser parser;
	478	FT_Byte* dict;
	479	FT_ULong dict_len;
	480	CFF_Font_Dict* top = &font->font_dict;
	481	CFF_Private* priv = &font->private_dict;
	482
	483
	484	T2_Parser_Init( &parser, T2CODE_TOPDICT, &font->font_dict );
	485
	486	/* set defaults */
	487	MEM_Set( top, 0, sizeof ( *top ) );
	488
	489	top->underline_position = -100;
	490	top->underline_thickness = 50;
	491	top->charstring_type = 2;
	492	top->font_matrix.xx = 0x10000L;
	493	top->font_matrix.yy = 0x10000L;
	494	top->cid_count = 8720;
	495
	496	error = T2_Access_Element( index, font_index, &dict, &dict_len ) \|\|
	497	T2_Parser_Run( &parser, dict, dict + dict_len );
	498
	499	T2_Forget_Element( index, &dict );
	500
	501	if ( error )
	502	goto Exit;
	503
	504	/* if it is a CID font, we stop there */
	505	if ( top->cid_registry )
	506	goto Exit;
	507
	508	/* parse the private dictionary, if any */
	509	if ( top->private_offset && top->private_size )
	510	{
	511	/* set defaults */
	512	MEM_Set( priv, 0, sizeof ( *priv ) );
	513
	514	priv->blue_shift = 7;
	515	priv->blue_fuzz = 1;
	516	priv->lenIV = -1;
	517	priv->expansion_factor = (FT_Fixed)0.06 * 0x10000L;
	518	priv->blue_scale = (FT_Fixed)0.039625 * 0x10000L;
	519
	520	T2_Parser_Init( &parser, T2CODE_PRIVATE, priv );
	521
	522	if ( FILE_Seek( base_offset + font->font_dict.private_offset ) \|\|
	523	ACCESS_Frame( font->font_dict.private_size ) )
	524	goto Exit;
	525
	526	error = T2_Parser_Run( &parser,
	527	(FT_Byte*)stream->cursor,
	528	(FT_Byte*)stream->limit );
	529	FORGET_Frame();
	530	if ( error )
	531	goto Exit;
	532	}
	533
	534	/* read the local subrs, if any */
	535	if ( priv->local_subrs_offset )
	536	{
	537	if ( FILE_Seek( base_offset + top->private_offset +
	538	priv->local_subrs_offset ) )
	539	goto Exit;
	540
	541	error = t2_new_cff_index( &font->local_subrs_index, stream, 1 );
	542	if ( error )
	543	goto Exit;
	544
	545	font->num_local_subrs = font->local_subrs_index.count;
	546	error = t2_explicit_cff_index( &font->local_subrs_index,
	547	&font->local_subrs );
	548	}
	549
	550	Exit:
	551	return error;
	552	}
	553
	554
	555	static
	556	void CFF_Done_SubFont( FT_Memory memory,
	557	CFF_SubFont* subfont )
	558	{
	559	if ( subfont )
	560	{
	561	t2_done_cff_index( &subfont->local_subrs_index );
	562	FREE( subfont->local_subrs );
	563	}
	564	}
	565
	566
	567	LOCAL_FUNC
	568	FT_Error T2_Load_CFF_Font( FT_Stream stream,
	569	FT_Int face_index,
	570	CFF_Font* font )
	571	{
	572	static const FT_Frame_Field cff_header_fields[] =
	573	{
	574	FT_FRAME_START( 4 ),
	575	FT_FRAME_BYTE( CFF_Font, version_major ),
	576	FT_FRAME_BYTE( CFF_Font, version_minor ),
	577	FT_FRAME_BYTE( CFF_Font, header_size ),
	578	FT_FRAME_BYTE( CFF_Font, absolute_offsize ),
	579	FT_FRAME_END
	580	};
	581
	582	FT_Error error;
	583	FT_Memory memory = stream->memory;
	584	FT_ULong base_offset;
	585	CFF_Font_Dict* dict;
	586
	587
	588	MEM_Set( font, 0, sizeof ( *font ) );
	589	font->stream = stream;
	590	font->memory = memory;
	591	dict = &font->top_font.font_dict;
	592	base_offset = FILE_Pos();
	593
	594	/* read CFF font header */
	595	if ( READ_Fields( cff_header_fields, font ) )
	596	goto Exit;
	597
	598	/* check format */
	599	if ( font->version_major != 1 \|\|
	600	font->header_size < 4 \|\|
	601	font->absolute_offsize > 4 )
	602	{
	603	FT_TRACE2(( "[not a CFF font header!]\n" ));
	604	error = FT_Err_Unknown_File_Format;
	605	goto Exit;
	606	}
	607
	608	/* skip the rest of the header */
	609	(void)FILE_Skip( font->header_size - 4 );
	610
	611	/* read the name, top dict, string and global subrs index */
	612	error = t2_new_cff_index( &font->name_index, stream, 0 ) \|\|
	613	t2_new_cff_index( &font->font_dict_index, stream, 0 ) \|\|
	614	t2_new_cff_index( &font->string_index, stream, 0 ) \|\|
	615	t2_new_cff_index( &font->global_subrs_index, stream, 1 );
	616	if ( error )
	617	goto Exit;
	618
	619	/* well, we don't really forget the `disabled' fonts... */
	620	font->num_faces = font->name_index.count;
	621	if ( face_index >= (FT_Int)font->num_faces )
	622	{
	623	FT_ERROR(( "T2_Load_CFF_Font: incorrect face index = %d\n",
	624	face_index ));
	625	error = T2_Err_Invalid_Argument;
	626	}
	627
	628	/* in case of a font format check, simply exit now */
	629	if ( face_index < 0 )
	630	goto Exit;
	631
	632	/* now, parse the top-level font dictionary */
	633	error = CFF_Load_SubFont( &font->top_font,
	634	&font->font_dict_index,
	635	face_index,
	636	stream,
	637	base_offset );
	638	if ( error )
	639	goto Exit;
	640
	641	/* now, check for a CID font */
	642	if ( dict->cid_registry )
	643	{
	644	CFF_Index fd_index;
	645	CFF_SubFont* sub;
	646	FT_UInt index;
	647
	648
	649	/* this is a CID-keyed font, we must now allocate a table of */
	650	/* sub-fonts, then load each of them separately */
	651	if ( FILE_Seek( base_offset + dict->cid_fd_array_offset ) )
	652	goto Exit;
	653
	654	error = t2_new_cff_index( &fd_index, stream, 0 );
	655	if ( error )
	656	goto Exit;
	657
	658	if ( fd_index.count > CFF_MAX_CID_FONTS )
	659	{
	660	FT_ERROR(( "T2_Load_CFF_Font: FD array too large in CID font\n" ));
	661	goto Fail_CID;
	662	}
	663
	664	/* allocate & read each font dict independently */
	665	font->num_subfonts = fd_index.count;
	666	if ( ALLOC_ARRAY( sub, fd_index.count, CFF_SubFont ) )
	667	goto Fail_CID;
	668
	669	/* setup pointer table */
	670	for ( index = 0; index < fd_index.count; index++ )
	671	font->subfonts[index] = sub + index;
	672
	673	/* now load each sub font independently */
	674	for ( index = 0; index < fd_index.count; index++ )
	675	{
	676	sub = font->subfonts[index];
	677	error = CFF_Load_SubFont( sub, &fd_index, index,
	678	stream, base_offset );
	679	if ( error )
	680	goto Fail_CID;
	681	}
	682
	683	/* now load the FD Select array */
	684	error = CFF_Load_FD_Select( &font->fd_select,
	685	dict->cid_count,
	686	stream,
	687	base_offset + dict->cid_fd_select_offset );
	688
	689	Fail_CID:
	690	t2_done_cff_index( &fd_index );
	691
	692	if ( error )
	693	goto Exit;
	694	}
	695	else
	696	font->num_subfonts = 0;
	697
	698	/* read the charstrings index now */
	699	if ( dict->charstrings_offset == 0 )
	700	{
	701	FT_ERROR(( "T2_Load_CFF_Font: no charstrings offset!\n" ));
	702	error = FT_Err_Unknown_File_Format;
	703	goto Exit;
	704	}
	705
	706	if ( FILE_Seek( base_offset + dict->charstrings_offset ) )
	707	goto Exit;
	708
	709	error = t2_new_cff_index( &font->charstrings_index, stream, 0 );
	710	if ( error )
	711	goto Exit;
	712
	713	/* explicit the global subrs */
	714	font->num_global_subrs = font->global_subrs_index.count;
	715	font->num_glyphs = font->charstrings_index.count;
	716
	717	error = t2_explicit_cff_index( &font->global_subrs_index,
	718	&font->global_subrs ) ;
	719
	720	if ( error )
	721	goto Exit;
	722
	723	/* get the font name */
	724	font->font_name = T2_Get_Name( &font->name_index, face_index );
	725
	726	Exit:
	727	return error;
	728	}
	729
	730
	731	LOCAL_FUNC
	732	void T2_Done_CFF_Font( CFF_Font* font )
	733	{
	734	FT_Memory memory = font->memory;
	735	FT_UInt index;
	736
	737
	738	t2_done_cff_index( &font->global_subrs_index );
	739	t2_done_cff_index( &font->string_index );
	740	t2_done_cff_index( &font->font_dict_index );
	741	t2_done_cff_index( &font->name_index );
	742	t2_done_cff_index( &font->charstrings_index );
	743
	744	/* release font dictionaries */
	745	for ( index = 0; index < font->num_subfonts; index++ )
	746	CFF_Done_SubFont( memory, font->subfonts[index] );
	747
	748	CFF_Done_SubFont( memory, &font->top_font );
	749
	750	CFF_Done_FD_Select( &font->fd_select, font->stream );
	751
	752	FREE( font->global_subrs );
	753	FREE( font->font_name );
	754	}
	755
	756
	757	/* END */