sfwoff2.h File Reference

#include <freetype/internal/sfnt.h>
#include <freetype/internal/ftobjs.h>

Include dependency graph for sfwoff2.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	WOFF2_FLAGS_TRANSFORM   1 << 8
#define	WOFF2_SFNT_HEADER_SIZE   12
#define	WOFF2_SFNT_ENTRY_SIZE   16
#define	WOFF2_DEFAULT_MAX_SIZE   30 * 1024 * 1024
#define	WOFF2_DEFAULT_GLYPH_BUF   5120
#define	FLAG_ARG_1_AND_2_ARE_WORDS   1 << 0
#define	FLAG_WE_HAVE_A_SCALE   1 << 3
#define	FLAG_MORE_COMPONENTS   1 << 5
#define	FLAG_WE_HAVE_AN_X_AND_Y_SCALE   1 << 6
#define	FLAG_WE_HAVE_A_TWO_BY_TWO   1 << 7
#define	FLAG_WE_HAVE_INSTRUCTIONS   1 << 8
#define	GLYF_ON_CURVE   1 << 0
#define	GLYF_X_SHORT   1 << 1
#define	GLYF_Y_SHORT   1 << 2
#define	GLYF_REPEAT   1 << 3
#define	GLYF_THIS_X_IS_SAME   1 << 4
#define	GLYF_THIS_Y_IS_SAME   1 << 5
#define	CONTOUR_OFFSET_END_POINT   10

Functions
	woff2_open_font (FT_Stream stream, TT_Face face, FT_Int *face_index, FT_Long *num_faces)

Macro Definition Documentation

CONTOUR_OFFSET_END_POINT

#define CONTOUR_OFFSET_END_POINT   10

Definition at line 60 of file sfwoff2.h.

FLAG_ARG_1_AND_2_ARE_WORDS

#define FLAG_ARG_1_AND_2_ARE_WORDS   1 << 0

Definition at line 44 of file sfwoff2.h.

FLAG_MORE_COMPONENTS

#define FLAG_MORE_COMPONENTS   1 << 5

Definition at line 46 of file sfwoff2.h.

FLAG_WE_HAVE_A_SCALE

#define FLAG_WE_HAVE_A_SCALE   1 << 3

Definition at line 45 of file sfwoff2.h.

FLAG_WE_HAVE_A_TWO_BY_TWO

#define FLAG_WE_HAVE_A_TWO_BY_TWO   1 << 7

Definition at line 48 of file sfwoff2.h.

FLAG_WE_HAVE_AN_X_AND_Y_SCALE

#define FLAG_WE_HAVE_AN_X_AND_Y_SCALE   1 << 6

Definition at line 47 of file sfwoff2.h.

FLAG_WE_HAVE_INSTRUCTIONS

#define FLAG_WE_HAVE_INSTRUCTIONS   1 << 8

Definition at line 49 of file sfwoff2.h.

GLYF_ON_CURVE

#define GLYF_ON_CURVE   1 << 0

Definition at line 52 of file sfwoff2.h.

GLYF_REPEAT

#define GLYF_REPEAT   1 << 3

Definition at line 55 of file sfwoff2.h.

GLYF_THIS_X_IS_SAME

#define GLYF_THIS_X_IS_SAME   1 << 4

Definition at line 56 of file sfwoff2.h.

GLYF_THIS_Y_IS_SAME

#define GLYF_THIS_Y_IS_SAME   1 << 5

Definition at line 57 of file sfwoff2.h.

GLYF_X_SHORT

#define GLYF_X_SHORT   1 << 1

Definition at line 53 of file sfwoff2.h.

GLYF_Y_SHORT

#define GLYF_Y_SHORT   1 << 2

Definition at line 54 of file sfwoff2.h.

WOFF2_DEFAULT_GLYPH_BUF

#define WOFF2_DEFAULT_GLYPH_BUF   5120

Definition at line 40 of file sfwoff2.h.

WOFF2_DEFAULT_MAX_SIZE

#define WOFF2_DEFAULT_MAX_SIZE   30 * 1024 * 1024

Definition at line 37 of file sfwoff2.h.

WOFF2_FLAGS_TRANSFORM

#define WOFF2_FLAGS_TRANSFORM   1 << 8

Definition at line 31 of file sfwoff2.h.

WOFF2_SFNT_ENTRY_SIZE

#define WOFF2_SFNT_ENTRY_SIZE   16

Definition at line 34 of file sfwoff2.h.

WOFF2_SFNT_HEADER_SIZE

#define WOFF2_SFNT_HEADER_SIZE   12

Definition at line 33 of file sfwoff2.h.

Function Documentation

woff2_open_font()

woff2_open_font	(	FT_Stream	stream,
		TT_Face	face,
		FT_Int *	face_index,
		FT_Long *	num_faces
	)

Definition at line 1750 of file sfwoff2.c.

  {
    FT_Memory  memory = stream->memory;
    FT_Error   error  = FT_Err_Ok;
    FT_Int     face_index;
 
    WOFF2_HeaderRec  woff2;
    WOFF2_InfoRec    info         = { 0, 0, 0, NULL, NULL, NULL, NULL };
    WOFF2_Table      tables       = NULL;
    WOFF2_Table*     indices      = NULL;
    WOFF2_Table*     temp_indices = NULL;
    WOFF2_Table      last_table;
 
    FT_Int     nn;
    FT_ULong   j;
    FT_ULong   flags;
    FT_UShort  xform_version;
    FT_ULong   src_offset = 0;
 
    FT_UInt    glyf_index;
    FT_UInt    loca_index;
    FT_UInt32  file_offset;
 
    FT_Byte*   sfnt        = NULL;
    FT_Stream  sfnt_stream = NULL;
    FT_Byte*   sfnt_header;
    FT_ULong   sfnt_size;
 
    FT_Byte*  uncompressed_buf = NULL;
 
    static const FT_Frame_Field  woff2_header_fields[] =
    {
#undef  FT_STRUCTURE
#define FT_STRUCTURE  WOFF2_HeaderRec
 
      FT_FRAME_START( 48 ),
        FT_FRAME_ULONG     ( signature ),
        FT_FRAME_ULONG     ( flavor ),
        FT_FRAME_ULONG     ( length ),
        FT_FRAME_USHORT    ( num_tables ),
        FT_FRAME_SKIP_BYTES( 2 ),
        FT_FRAME_ULONG     ( totalSfntSize ),
        FT_FRAME_ULONG     ( totalCompressedSize ),
        FT_FRAME_SKIP_BYTES( 2 * 2 ),
        FT_FRAME_ULONG     ( metaOffset ),
        FT_FRAME_ULONG     ( metaLength ),
        FT_FRAME_ULONG     ( metaOrigLength ),
        FT_FRAME_ULONG     ( privOffset ),
        FT_FRAME_ULONG     ( privLength ),
      FT_FRAME_END
    };
 
 
    FT_ASSERT( stream == face->root.stream );
    FT_ASSERT( FT_STREAM_POS() == 0 );
 
    face_index = FT_ABS( *face_instance_index ) & 0xFFFF;
 
    /* Read WOFF2 Header. */
    if ( FT_STREAM_READ_FIELDS( woff2_header_fields, &woff2 ) )
      return error;
 
    FT_TRACE4(( "signature     -> 0x%lX\n", woff2.signature ));
    FT_TRACE2(( "flavor        -> 0x%08lx\n", woff2.flavor ));
    FT_TRACE4(( "length        -> %lu\n", woff2.length ));
    FT_TRACE2(( "num_tables    -> %hu\n", woff2.num_tables ));
    FT_TRACE4(( "totalSfntSize -> %lu\n", woff2.totalSfntSize ));
    FT_TRACE4(( "metaOffset    -> %lu\n", woff2.metaOffset ));
    FT_TRACE4(( "metaLength    -> %lu\n", woff2.metaLength ));
    FT_TRACE4(( "privOffset    -> %lu\n", woff2.privOffset ));
    FT_TRACE4(( "privLength    -> %lu\n", woff2.privLength ));
 
    /* Make sure we don't recurse back here. */
    if ( woff2.flavor == TTAG_wOF2 )
      return FT_THROW( Invalid_Table );
 
    /* Miscellaneous checks. */
    if ( woff2.length != stream->size                               ||
         woff2.num_tables == 0                                      ||
         48 + woff2.num_tables * 20UL >= woff2.length               ||
         ( woff2.metaOffset == 0 && ( woff2.metaLength != 0     ||
                                      woff2.metaOrigLength != 0 ) ) ||
         ( woff2.metaLength != 0 && woff2.metaOrigLength == 0 )     ||
         ( woff2.metaOffset >= woff2.length )                       ||
         ( woff2.length - woff2.metaOffset < woff2.metaLength )     ||
         ( woff2.privOffset == 0 && woff2.privLength != 0 )         ||
         ( woff2.privOffset >= woff2.length )                       ||
         ( woff2.length - woff2.privOffset < woff2.privLength )     )
    {
      FT_ERROR(( "woff2_open_font: invalid WOFF2 header\n" ));
      return FT_THROW( Invalid_Table );
    }
 
    FT_TRACE2(( "woff2_open_font: WOFF2 Header is valid.\n" ));
 
    woff2.ttc_fonts = NULL;
 
    /* Read table directory. */
    if ( FT_NEW_ARRAY( tables, woff2.num_tables )  ||
         FT_NEW_ARRAY( indices, woff2.num_tables ) )
      goto Exit;
 
    FT_TRACE2((
      "\n"
      "  tag    flags    transform  origLen   transformLen   offset\n"
      "  -----------------------------------------------------------\n" ));
   /* "  XXXX  XXXXXXXX  XXXXXXXX   XXXXXXXX    XXXXXXXX    XXXXXXXX" */
 
    for ( nn = 0; nn < woff2.num_tables; nn++ )
    {
      WOFF2_Table  table = tables + nn;
 
 
      if ( FT_READ_BYTE( table->FlagByte ) )
        goto Exit;
 
      if ( ( table->FlagByte & 0x3f ) == 0x3f )
      {
        if ( FT_READ_ULONG( table->Tag ) )
          goto Exit;
      }
      else
      {
        table->Tag = woff2_known_tags( table->FlagByte & 0x3f );
        if ( !table->Tag )
        {
          FT_ERROR(( "woff2_open_font: Unknown table tag." ));
          error = FT_THROW( Invalid_Table );
          goto Exit;
        }
      }
 
      flags = 0;
      xform_version = ( table->FlagByte >> 6 ) & 0x03;
 
      /* 0 means xform for glyph/loca, non-0 for others. */
      if ( table->Tag == TTAG_glyf || table->Tag == TTAG_loca )
      {
        if ( xform_version == 0 )
          flags |= WOFF2_FLAGS_TRANSFORM;
      }
      else if ( xform_version != 0 )
        flags |= WOFF2_FLAGS_TRANSFORM;
 
      flags |= xform_version;
 
      if ( READ_BASE128( table->dst_length ) )
        goto Exit;
 
      table->TransformLength = table->dst_length;
 
      if ( ( flags & WOFF2_FLAGS_TRANSFORM ) != 0 )
      {
        if ( READ_BASE128( table->TransformLength ) )
          goto Exit;
 
        if ( table->Tag == TTAG_loca && table->TransformLength )
        {
          FT_ERROR(( "woff2_open_font: Invalid loca `transformLength'.\n" ));
          error = FT_THROW( Invalid_Table );
          goto Exit;
        }
      }
 
      if ( src_offset + table->TransformLength < src_offset )
      {
        FT_ERROR(( "woff2_open_font: invalid WOFF2 table directory.\n" ));
        error = FT_THROW( Invalid_Table );
        goto Exit;
      }
 
      table->src_offset = src_offset;
      table->src_length = table->TransformLength;
      src_offset       += table->TransformLength;
      table->flags      = flags;
 
      FT_TRACE2(( "  %c%c%c%c  %08d  %08d   %08ld    %08ld    %08ld\n",
                  (FT_Char)( table->Tag >> 24 ),
                  (FT_Char)( table->Tag >> 16 ),
                  (FT_Char)( table->Tag >> 8  ),
                  (FT_Char)( table->Tag       ),
                  table->FlagByte & 0x3f,
                  ( table->FlagByte >> 6 ) & 0x03,
                  table->dst_length,
                  table->TransformLength,
                  table->src_offset ));
 
      indices[nn] = table;
    }
 
    /* End of last table is uncompressed size. */
    last_table = indices[woff2.num_tables - 1];
 
    woff2.uncompressed_size = last_table->src_offset +
                              last_table->src_length;
    if ( woff2.uncompressed_size < last_table->src_offset )
    {
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
 
    FT_TRACE2(( "Table directory parsed.\n" ));
 
    /* Check for and read collection directory. */
    woff2.num_fonts      = 1;
    woff2.header_version = 0;
 
    if ( woff2.flavor == TTAG_ttcf )
    {
      FT_TRACE2(( "Font is a TTC, reading collection directory.\n" ));
 
      if ( FT_READ_ULONG( woff2.header_version ) )
        goto Exit;
 
      if ( woff2.header_version != 0x00010000 &&
           woff2.header_version != 0x00020000 )
      {
        error = FT_THROW( Invalid_Table );
        goto Exit;
      }
 
      if ( READ_255USHORT( woff2.num_fonts ) )
        goto Exit;
 
      if ( !woff2.num_fonts )
      {
        error = FT_THROW( Invalid_Table );
        goto Exit;
      }
 
      FT_TRACE4(( "Number of fonts in TTC: %d\n", woff2.num_fonts ));
 
      if ( FT_NEW_ARRAY( woff2.ttc_fonts, woff2.num_fonts ) )
        goto Exit;
 
      for ( nn = 0; nn < woff2.num_fonts; nn++ )
      {
        WOFF2_TtcFont  ttc_font = woff2.ttc_fonts + nn;
 
 
        if ( READ_255USHORT( ttc_font->num_tables ) )
          goto Exit;
        if ( FT_READ_ULONG( ttc_font->flavor ) )
          goto Exit;
 
        if ( FT_NEW_ARRAY( ttc_font->table_indices, ttc_font->num_tables ) )
          goto Exit;
 
        FT_TRACE5(( "Number of tables in font %d: %d\n",
                    nn, ttc_font->num_tables ));
 
#ifdef FT_DEBUG_LEVEL_TRACE
        if ( ttc_font->num_tables )
          FT_TRACE6(( "  Indices: " ));
#endif
 
        glyf_index = 0;
        loca_index = 0;
 
        for ( j = 0; j < ttc_font->num_tables; j++ )
        {
          FT_UShort    table_index;
          WOFF2_Table  table;
 
 
          if ( READ_255USHORT( table_index ) )
            goto Exit;
 
          FT_TRACE6(( "%hu ", table_index ));
          if ( table_index >= woff2.num_tables )
          {
            FT_ERROR(( "woff2_open_font: invalid table index\n" ));
            error = FT_THROW( Invalid_Table );
            goto Exit;
          }
 
          ttc_font->table_indices[j] = table_index;
 
          table = indices[table_index];
          if ( table->Tag == TTAG_loca )
            loca_index = table_index;
          if ( table->Tag == TTAG_glyf )
            glyf_index = table_index;
        }
 
#ifdef FT_DEBUG_LEVEL_TRACE
        if ( ttc_font->num_tables )
          FT_TRACE6(( "\n" ));
#endif
 
        /* glyf and loca must be consecutive */
        if ( glyf_index > 0 || loca_index > 0 )
        {
          if ( glyf_index > loca_index      ||
               loca_index - glyf_index != 1 )
          {
            error = FT_THROW( Invalid_Table );
            goto Exit;
          }
        }
      }
 
      /* Collection directory reading complete. */
      FT_TRACE2(( "WOFF2 collection directory is valid.\n" ));
    }
    else
      woff2.ttc_fonts = NULL;
 
    woff2.compressed_offset = FT_STREAM_POS();
    file_offset             = ROUND4( woff2.compressed_offset +
                                      woff2.totalCompressedSize );
 
    /* Some more checks before we start reading the tables. */
    if ( file_offset > woff2.length )
    {
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
 
    if ( woff2.metaOffset )
    {
      if ( file_offset != woff2.metaOffset )
      {
        error = FT_THROW( Invalid_Table );
        goto Exit;
      }
      file_offset = ROUND4(woff2.metaOffset + woff2.metaLength);
    }
 
    if ( woff2.privOffset )
    {
      if ( file_offset != woff2.privOffset )
      {
        error = FT_THROW( Invalid_Table );
        goto Exit;
      }
      file_offset = ROUND4(woff2.privOffset + woff2.privLength);
    }
 
    if ( file_offset != ( ROUND4( woff2.length ) ) )
    {
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
 
    /* Validate requested face index. */
    *num_faces = woff2.num_fonts;
    /* value -(N+1) requests information on index N */
    if ( *face_instance_index < 0 )
      face_index--;
 
    if ( face_index >= woff2.num_fonts )
    {
      if ( *face_instance_index >= 0 )
      {
        error = FT_THROW( Invalid_Argument );
        goto Exit;
      }
      else
        face_index = 0;
    }
 
    /* Only retain tables of the requested face in a TTC. */
    if ( woff2.header_version )
    {
      WOFF2_TtcFont  ttc_font = woff2.ttc_fonts + face_index;
 
 
      /* Create a temporary array. */
      if ( FT_NEW_ARRAY( temp_indices,
                         ttc_font->num_tables ) )
        goto Exit;
 
      FT_TRACE4(( "Storing tables for TTC face index %d.\n", face_index ));
      for ( nn = 0; nn < ttc_font->num_tables; nn++ )
        temp_indices[nn] = indices[ttc_font->table_indices[nn]];
 
      /* Resize array to required size. */
      if ( FT_RENEW_ARRAY( indices,
                           woff2.num_tables,
                           ttc_font->num_tables ) )
        goto Exit;
 
      for ( nn = 0; nn < ttc_font->num_tables; nn++ )
        indices[nn] = temp_indices[nn];
 
      FT_FREE( temp_indices );
 
      /* Change header values. */
      woff2.flavor     = ttc_font->flavor;
      woff2.num_tables = ttc_font->num_tables;
    }
 
    /* We need to allocate this much at the minimum. */
    sfnt_size = 12 + woff2.num_tables * 16UL;
    /* This is what we normally expect.                              */
    /* Initially trust `totalSfntSize' and change later as required. */
    if ( woff2.totalSfntSize > sfnt_size )
    {
      /* However, adjust the value to something reasonable. */
 
      /* Factor 64 is heuristic. */
      if ( ( woff2.totalSfntSize >> 6 ) > woff2.length )
        sfnt_size = woff2.length << 6;
      else
        sfnt_size = woff2.totalSfntSize;
 
      /* Value 1<<26 = 67108864 is heuristic. */
      if (sfnt_size >= (1 << 26))
        sfnt_size = 1 << 26;
 
#ifdef FT_DEBUG_LEVEL_TRACE
      if ( sfnt_size != woff2.totalSfntSize )
        FT_TRACE4(( "adjusting estimate of uncompressed font size"
                    " to %lu bytes\n",
                    sfnt_size ));
#endif
    }
 
    /* Write sfnt header. */
    if ( FT_ALLOC( sfnt, sfnt_size ) ||
         FT_NEW( sfnt_stream )       )
      goto Exit;
 
    sfnt_header = sfnt;
 
    WRITE_ULONG( sfnt_header, woff2.flavor );
 
    if ( woff2.num_tables )
    {
      FT_UInt  searchRange, entrySelector, rangeShift, x;
 
 
      x             = woff2.num_tables;
      entrySelector = 0;
      while ( x )
      {
        x            >>= 1;
        entrySelector += 1;
      }
      entrySelector--;
 
      searchRange = ( 1 << entrySelector ) * 16;
      rangeShift  = ( woff2.num_tables * 16 ) - searchRange;
 
      WRITE_USHORT( sfnt_header, woff2.num_tables );
      WRITE_USHORT( sfnt_header, searchRange );
      WRITE_USHORT( sfnt_header, entrySelector );
      WRITE_USHORT( sfnt_header, rangeShift );
    }
 
    info.header_checksum = compute_ULong_sum( sfnt, 12 );
 
    /* Sort tables by tag. */
    ft_qsort( indices,
              woff2.num_tables,
              sizeof ( WOFF2_Table ),
              compare_tags );
 
    if ( woff2.uncompressed_size < 1 )
    {
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
 
    if ( woff2.uncompressed_size > sfnt_size )
    {
      FT_ERROR(( "woff2_open_font: SFNT table lengths are too large.\n" ));
      error = FT_THROW( Invalid_Table );
      goto Exit;
    }
 
    /* Allocate memory for uncompressed table data. */
    if ( FT_ALLOC( uncompressed_buf, woff2.uncompressed_size ) ||
         FT_FRAME_ENTER( woff2.totalCompressedSize )           )
      goto Exit;
 
    /* Uncompress the stream. */
    error = woff2_decompress( uncompressed_buf,
                              woff2.uncompressed_size,
                              stream->cursor,
                              woff2.totalCompressedSize );
 
    FT_FRAME_EXIT();
 
    if ( error )
      goto Exit;
 
    error = reconstruct_font( uncompressed_buf,
                              woff2.uncompressed_size,
                              indices,
                              &woff2,
                              &info,
                              &sfnt,
                              &sfnt_size,
                              memory );
 
    if ( error )
      goto Exit;
 
    /* Resize `sfnt' to actual size of sfnt stream. */
    if ( woff2.actual_sfnt_size < sfnt_size )
    {
      FT_TRACE5(( "Trimming sfnt stream from %lu to %lu.\n",
                  sfnt_size, woff2.actual_sfnt_size ));
      if ( FT_REALLOC( sfnt,
                       (FT_ULong)( sfnt_size ),
                       (FT_ULong)( woff2.actual_sfnt_size ) ) )
        goto Exit;
    }
 
    /* `reconstruct_font' has done all the work. */
    /* Swap out stream and return.               */
    FT_Stream_OpenMemory( sfnt_stream, sfnt, woff2.actual_sfnt_size );
    sfnt_stream->memory = stream->memory;
    sfnt_stream->close  = stream_close;
 
    FT_Stream_Free(
      face->root.stream,
      ( face->root.face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 );
 
    face->root.stream      = sfnt_stream;
    face->root.face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
 
    /* Set face_index to 0 or -1. */
    if ( *face_instance_index >= 0 )
      *face_instance_index = 0;
    else
      *face_instance_index = -1;
 
    FT_TRACE2(( "woff2_open_font: SFNT synthesized.\n" ));
 
  Exit:
    FT_FREE( tables );
    FT_FREE( indices );
    FT_FREE( uncompressed_buf );
    FT_FREE( info.x_mins );
 
    if ( woff2.ttc_fonts )
    {
      WOFF2_TtcFont  ttc_font = woff2.ttc_fonts;
 
 
      for ( nn = 0; nn < woff2.num_fonts; nn++ )
      {
        FT_FREE( ttc_font->table_indices );
        ttc_font++;
      }
 
      FT_FREE( woff2.ttc_fonts );
    }
 
    if ( error )
    {
      FT_FREE( sfnt );
      if ( sfnt_stream )
      {
        FT_Stream_Close( sfnt_stream );
        FT_FREE( sfnt_stream );
      }
    }
 
    return error;
  }

Referenced by sfnt_open_font().