Ignore:
Timestamp:
Jan 17, 2009, 10:45:05 AM (12 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: freetype library updated to version 2.3.8

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/src/base/ftmac.c

    r251 r262  
    99/*  classic platforms built by MPW.                                        */
    1010/*                                                                         */
    11 /*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by       */
     11/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,         */
     12/*            2009 by                                                      */
    1213/*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
    1314/*                                                                         */
     
    6869#include <ft2build.h>
    6970#include FT_FREETYPE_H
     71#include FT_TRUETYPE_TAGS_H
    7072#include FT_INTERNAL_STREAM_H
     73#include "ftbase.h"
    7174
    7275  /* This is for Mac OS X.  Without redefinition, OS_INLINE */
     
    7881#endif
    7982
    80   /* The ResourceIndex type was available SDKs on 10.5 */
     83  /* `configure' checks the availability of `ResourceIndex' strictly */
     84  /* and sets HAVE_TYPE_RESOURCE_INDEX 1 or 0 always.  If it is      */
     85  /* not set (e.g., a build without `configure'), the availability   */
     86  /* is guessed from the SDK version.                                */
    8187#ifndef HAVE_TYPE_RESOURCE_INDEX
    82 typedef short ResourceIndex;
     88#if !defined( MAC_OS_X_VERSION_10_5 ) || \
     89    ( MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5 )
     90#define HAVE_TYPE_RESOURCE_INDEX 0
     91#else
     92#define HAVE_TYPE_RESOURCE_INDEX 1
     93#endif
     94#endif /* !HAVE_TYPE_RESOURCE_INDEX */
     95
     96#if ( HAVE_TYPE_RESOURCE_INDEX == 0 )
     97  typedef short  ResourceIndex;
    8398#endif
    8499
     
    87102#include <sys/syslimits.h> /* PATH_MAX */
    88103
     104  /* Don't want warnings about our own use of deprecated functions. */
    89105#define FT_DEPRECATED_ATTRIBUTE
    90106
    91107#include FT_MAC_H
    92 
    93   /* undefine blocking-macros in ftmac.h */
    94 #undef FT_GetFile_From_Mac_Name( a, b, c )
    95 #undef FT_GetFile_From_Mac_ATS_Name( a, b, c )
    96 #undef FT_New_Face_From_FOND( a, b, c, d )
    97 #undef FT_New_Face_From_FSSpec( a, b, c, d )
    98 #undef FT_New_Face_From_FSRef( a, b, c, d )
    99108
    100109#ifndef kATSOptionFlagsUnRestrictedScope /* since Mac OS X 10.1 */
     
    590599    for (;;)
    591600    {
    592       post_data = Get1Resource( FT_MAKE_TAG( 'P', 'O', 'S', 'T' ),
    593                                 res_id++ );
     601      post_data = Get1Resource( TTAG_POST, res_id++ );
    594602      if ( post_data == NULL )
    595603        break;  /* we are done */
     
    630638    for (;;)
    631639    {
    632       post_data = Get1Resource( FT_MAKE_TAG( 'P', 'O', 'S', 'T' ),
    633                                 res_id++ );
     640      post_data = Get1Resource( TTAG_POST, res_id++ );
    634641      if ( post_data == NULL )
    635642        break;  /* we are done */
     
    683690
    684691
    685   /* Finalizer for a memory stream; gets called by FT_Done_Face().
    686      It frees the memory it uses. */
    687   static void
    688   memory_stream_close( FT_Stream  stream )
    689   {
    690     FT_Memory  memory = stream->memory;
    691 
    692 
    693     FT_FREE( stream->base );
    694 
    695     stream->size  = 0;
    696     stream->base  = 0;
    697     stream->close = 0;
    698   }
    699 
    700 
    701   /* Create a new memory stream from a buffer and a size. */
    702   static FT_Error
    703   new_memory_stream( FT_Library           library,
    704                      FT_Byte*             base,
    705                      FT_ULong             size,
    706                      FT_Stream_CloseFunc  close,
    707                      FT_Stream*           astream )
    708   {
    709     FT_Error   error;
    710     FT_Memory  memory;
    711     FT_Stream  stream;
    712 
    713 
    714     if ( !library )
    715       return FT_Err_Invalid_Library_Handle;
    716 
    717     if ( !base )
    718       return FT_Err_Invalid_Argument;
    719 
    720     *astream = 0;
    721     memory = library->memory;
    722     if ( FT_NEW( stream ) )
    723       goto Exit;
    724 
    725     FT_Stream_OpenMemory( stream, base, size );
    726 
    727     stream->close = close;
    728 
    729     *astream = stream;
    730 
    731   Exit:
    732     return error;
    733   }
    734 
    735 
    736   /* Create a new FT_Face given a buffer and a driver name. */
    737   static FT_Error
    738   open_face_from_buffer( FT_Library   library,
    739                          FT_Byte*     base,
    740                          FT_ULong     size,
    741                          FT_Long      face_index,
    742                          const char*  driver_name,
    743                          FT_Face*     aface )
    744   {
    745     FT_Open_Args  args;
    746     FT_Error      error;
    747     FT_Stream     stream;
    748     FT_Memory     memory = library->memory;
    749 
    750 
    751     error = new_memory_stream( library,
    752                                base,
    753                                size,
    754                                memory_stream_close,
    755                                &stream );
    756     if ( error )
    757     {
    758       FT_FREE( base );
    759       return error;
    760     }
    761 
    762     args.flags  = FT_OPEN_STREAM;
    763     args.stream = stream;
    764     if ( driver_name )
    765     {
    766       args.flags  = args.flags | FT_OPEN_DRIVER;
    767       args.driver = FT_Get_Module( library, driver_name );
    768     }
    769 
    770     /* At this point, face_index has served its purpose;      */
    771     /* whoever calls this function has already used it to     */
    772     /* locate the correct font data.  We should not propagate */
    773     /* this index to FT_Open_Face() (unless it is negative).  */
    774 
    775     if ( face_index > 0 )
    776       face_index = 0;
    777 
    778     error = FT_Open_Face( library, &args, face_index, aface );
    779     if ( error == FT_Err_Ok )
    780       (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM;
    781     else
    782       FT_Stream_Free( stream, 0 );
    783 
    784     return error;
    785   }
    786 
    787 
    788   /* Create a new FT_Face from a file spec to an LWFN file. */
     692  /* Create a new FT_Face from a file path to an LWFN file. */
    789693  static FT_Error
    790694  FT_New_Face_From_LWFN( FT_Library    library,
     
    830734    FT_Error   error  = FT_Err_Ok;
    831735    FT_Memory  memory = library->memory;
    832     int        is_cff;
    833 
    834 
    835     sfnt = GetResource( FT_MAKE_TAG( 's', 'f', 'n', 't' ), sfnt_id );
     736    int        is_cff, is_sfnt_ps;
     737
     738
     739    sfnt = GetResource( TTAG_sfnt, sfnt_id );
    836740    if ( sfnt == NULL )
    837741      return FT_Err_Invalid_Handle;
     
    847751    ReleaseResource( sfnt );
    848752
    849     is_cff = sfnt_size > 4 && sfnt_data[0] == 'O' &&
    850                               sfnt_data[1] == 'T' &&
    851                               sfnt_data[2] == 'T' &&
    852                               sfnt_data[3] == 'O';
    853 
    854     return open_face_from_buffer( library,
    855                                   sfnt_data,
    856                                   sfnt_size,
    857                                   face_index,
    858                                   is_cff ? "cff" : "truetype",
    859                                   aface );
    860   }
    861 
    862 
    863   /* Create a new FT_Face from a file spec to a suitcase file. */
     753    is_cff     = sfnt_size > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 );
     754    is_sfnt_ps = sfnt_size > 4 && !ft_memcmp( sfnt_data, "typ1", 4 );
     755
     756    if ( is_sfnt_ps )
     757    {
     758      FT_Stream  stream;
     759
     760
     761      if ( FT_NEW( stream ) )
     762        goto Try_OpenType;
     763
     764      FT_Stream_OpenMemory( stream, sfnt_data, sfnt_size );
     765      if ( !open_face_PS_from_sfnt_stream( library,
     766                                           stream,
     767                                           face_index,
     768                                           0, NULL,
     769                                           aface ) )
     770      {
     771        FT_Stream_Close( stream );
     772        FT_FREE( stream );
     773        FT_FREE( sfnt_data );
     774        goto Exit;
     775      }
     776
     777      FT_FREE( stream );
     778    }
     779  Try_OpenType:
     780    error = open_face_from_buffer( library,
     781                                   sfnt_data,
     782                                   sfnt_size,
     783                                   face_index,
     784                                   is_cff ? "cff" : "truetype",
     785                                   aface );
     786  Exit:
     787    return error;
     788  }
     789
     790
     791  /* Create a new FT_Face from a file path to a suitcase file. */
    864792  static FT_Error
    865793  FT_New_Face_From_Suitcase( FT_Library    library,
     
    885813    for ( res_index = 1; ; ++res_index )
    886814    {
    887       fond = Get1IndResource( FT_MAKE_TAG( 'F', 'O', 'N', 'D' ),
    888                               res_index );
     815      fond = Get1IndResource( TTAG_FOND, res_index );
    889816      if ( ResError() )
    890817        break;
     
    925852
    926853    GetResInfo( fond, &fond_id, &fond_type, fond_name );
    927     if ( ResError() != noErr || fond_type != FT_MAKE_TAG( 'F', 'O', 'N', 'D' ) )
     854    if ( ResError() != noErr || fond_type != TTAG_FOND )
    928855      return FT_Err_Invalid_File_Format;
    929856
     
    992919    /* LWFN is a (very) specific file format, check for it explicitly */
    993920    file_type = get_file_type_from_path( pathname );
    994     if ( file_type == FT_MAKE_TAG( 'L', 'W', 'F', 'N' ) )
     921    if ( file_type == TTAG_LWFN )
    995922      return FT_New_Face_From_LWFN( library, pathname, face_index, aface );
    996923
Note: See TracChangeset for help on using the changeset viewer.