noinst_LTLIBRARIES = libpango-ot.la
libpango_ot_la_SOURCES = \
- fterrcompat.h \
+ ftglue.h \
+ ftglue.c \
ftxopen.c \
ftxopen.h \
ftxopenf.h \
+++ /dev/null
-/* Pango
- * fterrcompat.h: Compat defines for compiling with newer versions
- * of FreeType
- *
- * Copyright © 2003 Red Hat, Inc
- *
- * The code is dual-licensed under the GNU Public License and the
- * FreeType license. See see FT-license.txt for full details.
- */
-#ifndef FTERRCOMPAT_H
-#define FTERRCOMPAT_H
-
-#include <config.h>
-
-#define TT_Err_Ok FT_Err_Ok
-#define TT_Err_Invalid_Argument FT_Err_Invalid_Argument
-#define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle
-#define TT_Err_Table_Missing FT_Err_Table_Missing
-
-/* Compat macros for name changes in FreeType 2.1.0
- */
-#if (FREETYPE_MAJOR == 2) && (FREETYPE_MINOR >= 1)
-
-#define FILE_Pos() FT_STREAM_POS()
-#define FILE_Seek( position ) FT_STREAM_SEEK( position)
-
-#define ACCESS_Frame( size ) FT_FRAME_ENTER( size )
-#define FORGET_Frame() FT_FRAME_EXIT()
-
-#define GET_Char() FT_GET_CHAR()
-#define GET_Byte() FT_GET_BYTE()
-#define GET_Short() FT_GET_SHORT()
-#define GET_UShort() FT_GET_USHORT()
-#define GET_Offset() FT_GET_OFF3()
-#define GET_UOffset() FT_GET_UOFF3()
-#define GET_Long() FT_GET_LONG()
-#define GET_ULong() FT_GET_ULONG()
-#define GET_Tag4() FT_GET_TAG4()
-
-/* Macro definitions to avoid bogus warnings about strict
- * aliasing. These make code generation worse, so we only
- * use them when necessary
- */
-#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
-#define ALLOC_ARRAY( _pointer_, _count_, _type_ ) ({ \
- int result; \
- void *_tmp_; \
- result = FT_SET_ERROR ( FT_MEM_ALLOC_ARRAY ( _tmp_, \
- _count_, \
- _type_ ) ); \
- _pointer_ = _tmp_; \
- result; \
-})
-
-/* FT_MEM_REALLOC macro broken in 2.1.0 */
-#define REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ ) ({ \
- int result; \
- void *_tmp_ = _pointer_; \
- result = FT_SET_ERROR ( FT_MEM_REALLOC( _tmp_, \
- (_old_) * sizeof ( _type_ ), \
- (_new_) * sizeof ( _type_ ) ) ); \
- _pointer_ = _tmp_; \
- result; \
-})
-
-#define FREE( _pointer_ ) ({ \
- void *_tmp_ = _pointer_; \
- FT_FREE ( _tmp_ ); \
- _pointer_ = _tmp_; \
-})
-#define ALLOC( _pointer_, _size_ ) ({ \
- int result; \
- void *_tmp_; \
- result = FT_ALLOC( _tmp_, _size_ ); \
- _pointer_ = _tmp_; \
- result; \
-})
-#else
-#define ALLOC_ARRAY( _pointer_, _count_, _type_ ) \
- FT_SET_ERROR (FT_MEM_ALLOC_ARRAY( _pointer_, _count_, _type_))
-
-/* FT_MEM_REALLOC macro broken in 2.1.0 */
-#define REALLOC_ARRAY( _pointer_, _old_, _new_, _type_ ) \
- FT_SET_ERROR ( FT_MEM_REALLOC( _pointer_, (_old_) * sizeof ( _type_ ), \
- (_new_) * sizeof ( _type_ ) ) )
-
-#define FREE( _pointer_ ) FT_FREE( _pointer_ )
-#define ALLOC( _pointer_, _size_ ) FT_ALLOC( _pointer_, _size_ )
-#endif /* gcc >= 3.3 */
-
-#define MEM_Copy( dest, source, count ) FT_MEM_COPY( dest, source, count )
-
-#endif /* freetype >= 2.1.0 */
-
-#endif /* FTERRCOMPAT_H */
--- /dev/null
+/* ftglue.c: Glue code for compiling the OpenType code from
+ * FreeType 1 using only the public API of FreeType 2
+ *
+ * By David Turner, The FreeType Project (www.freetype.org)
+ *
+ * This code is explicitely put in the public domain
+ *
+ * See ftglue.h for more information.
+ */
+
+#include "ftglue.h"
+
+#if 0
+#include <stdio.h>
+#define LOG(x) ftglue_log x
+
+static void
+ftglue_log( const char* format, ... )
+{
+ va_list ap;
+
+ va_start( ap, format );
+ vfprintf( stderr, format, ap );
+ va_end( ap );
+}
+
+#else
+#define LOG(x) do {} while (0)
+#endif
+
+/* only used internally */
+static FT_Pointer
+ftglue_qalloc( FT_Memory memory,
+ FT_ULong size,
+ FT_Error *perror )
+{
+ FT_Error error = 0;
+ FT_Pointer block = NULL;
+
+ if ( size > 0 )
+ {
+ block = memory->alloc( memory, size );
+ if ( !block )
+ error = FT_Err_Out_Of_Memory;
+ }
+
+ *perror = error;
+ return block;
+}
+
+#undef QALLOC /* just in case */
+#define QALLOC(ptr,size) ( (ptr) = ftglue_qalloc( memory, (size), &error ), error != 0 )
+
+
+FTGLUE_APIDEF( FT_Pointer )
+ftglue_alloc( FT_Memory memory,
+ FT_ULong size,
+ FT_Error *perror )
+{
+ FT_Error error = 0;
+ FT_Pointer block = NULL;
+
+ if ( size > 0 )
+ {
+ block = memory->alloc( memory, size );
+ if ( !block )
+ error = FT_Err_Out_Of_Memory;
+ else
+ memset( (char*)block, 0, (size_t)size );
+ }
+
+ *perror = error;
+ return block;
+}
+
+
+FTGLUE_APIDEF( FT_Pointer )
+ftglue_realloc( FT_Memory memory,
+ FT_Pointer block,
+ FT_ULong old_size,
+ FT_ULong new_size,
+ FT_Error *perror )
+{
+ FT_Pointer block2 = NULL;
+ FT_Error error = 0;
+
+ if ( old_size == 0 || block == NULL )
+ {
+ block2 = ftglue_alloc( memory, new_size, &error );
+ }
+ else if ( new_size == 0 )
+ {
+ ftglue_free( memory, block );
+ block2 = NULL;
+ }
+ else
+ {
+ block2 = memory->realloc( memory, old_size, new_size, block );
+ if ( block2 == NULL )
+ error = FT_Err_Out_Of_Memory;
+ else if ( new_size > old_size )
+ memset( (char*)block2 + old_size, 0, (size_t)(new_size - old_size) );
+ }
+
+ if ( !error )
+ block = block2;
+
+ *perror = error;
+ return block;
+}
+
+
+FTGLUE_APIDEF( void )
+ftglue_free( FT_Memory memory,
+ FT_Pointer block )
+{
+ if ( block )
+ memory->free( memory, block );
+}
+
+
+FTGLUE_APIDEF( FT_Long )
+ftglue_stream_pos( FT_Stream stream )
+{
+ LOG(( "ftglue:stream:pos() -> %ld\n", stream->pos ));
+ return stream->pos;
+}
+
+
+FTGLUE_APIDEF( FT_Error )
+ftglue_stream_seek( FT_Stream stream,
+ FT_Long pos )
+{
+ FT_Error error = 0;
+
+ stream->pos = pos;
+ if ( stream->read )
+ {
+ if ( stream->read( stream, pos, 0, 0 ) )
+ error = FT_Err_Invalid_Stream_Operation;
+ }
+ else if ( pos > stream->size )
+ error = FT_Err_Invalid_Stream_Operation;
+
+ LOG(( "ftglue:stream:seek(%ld) -> %d\n", pos, error ));
+ return error;
+}
+
+
+FTGLUE_APIDEF( FT_Error )
+ftglue_stream_frame_enter( FT_Stream stream,
+ FT_ULong count )
+{
+ FT_Error error = FT_Err_Ok;
+ FT_ULong read_bytes;
+
+ if ( stream->read )
+ {
+ /* allocate the frame in memory */
+ FT_Memory memory = stream->memory;
+
+
+ if ( QALLOC( stream->base, count ) )
+ goto Exit;
+
+ /* read it */
+ read_bytes = stream->read( stream, stream->pos,
+ stream->base, count );
+ if ( read_bytes < count )
+ {
+ FREE( stream->base );
+ error = FT_Err_Invalid_Stream_Operation;
+ }
+ stream->cursor = stream->base;
+ stream->limit = stream->cursor + count;
+ stream->pos += read_bytes;
+ }
+ else
+ {
+ /* check current and new position */
+ if ( stream->pos >= stream->size ||
+ stream->pos + count > stream->size )
+ {
+ error = FT_Err_Invalid_Stream_Operation;
+ goto Exit;
+ }
+
+ /* set cursor */
+ stream->cursor = stream->base + stream->pos;
+ stream->limit = stream->cursor + count;
+ stream->pos += count;
+ }
+
+Exit:
+ LOG(( "ftglue:stream:frame_enter(%ld) -> %d\n", count, error ));
+ return error;
+}
+
+
+FTGLUE_APIDEF( void )
+ftglue_stream_frame_exit( FT_Stream stream )
+{
+ if ( stream->read )
+ {
+ FT_Memory memory = stream->memory;
+
+ FREE( stream->base );
+ }
+ stream->cursor = 0;
+ stream->limit = 0;
+
+ LOG(( "ftglue:stream:frame_exit()\n" ));
+}
+
+
+FTGLUE_APIDEF( FT_Byte )
+ftglue_stream_get_byte( FT_Stream stream )
+{
+ FT_Byte result = 0;
+
+ if ( stream->cursor < stream->limit )
+ result = *stream->cursor++;
+
+ return result;
+}
+
+
+FTGLUE_APIDEF( FT_Short )
+ftglue_stream_get_short( FT_Stream stream )
+{
+ FT_Byte* p;
+ FT_Short result = 0;
+
+ p = stream->cursor;
+ if ( p + 2 <= stream->limit )
+ {
+ result = (FT_Short)((p[0] << 8) | p[1]);
+ stream->cursor = p+2;
+ }
+ return result;
+}
+
+
+FTGLUE_APIDEF( FT_Long )
+ftglue_stream_get_long( FT_Stream stream )
+{
+ FT_Byte* p;
+ FT_Long result = 0;
+
+ p = stream->cursor;
+ if ( p + 4 <= stream->limit )
+ {
+ result = (FT_Long)(((FT_Long)p[0] << 24) |
+ ((FT_Long)p[1] << 16) |
+ ((FT_Long)p[2] << 8) |
+ p[3] );
+ stream->cursor = p+4;
+ }
+ return result;
+}
+
+
+FTGLUE_APIDEF( FT_Error )
+ftglue_face_goto_table( FT_Face face,
+ FT_ULong the_tag,
+ FT_Stream stream )
+{
+ FT_Error error;
+
+ LOG(( "ftglue_face_goto_table( %p, %c%c%c%c, %p )\n",
+ face,
+ (int)((the_tag >> 24) & 0xFF),
+ (int)((the_tag >> 16) & 0xFF),
+ (int)((the_tag >> 8) & 0xFF),
+ (int)(the_tag & 0xFF),
+ stream ));
+
+ if ( !FT_IS_SFNT(face) )
+ {
+ LOG(( "not a SFNT face !!\n" ));
+ error = FT_Err_Invalid_Face_Handle;
+ }
+ else
+ {
+ /* parse the directory table directly, without using
+ * FreeType's built-in data structures
+ */
+ FT_ULong offset = 0;
+ FT_UInt count, nn;
+
+ if ( face->num_faces > 1 )
+ {
+ /* deal with TrueType collections */
+ FT_ULong offset;
+
+ LOG(( ">> This is a TrueType Collection\n" ));
+
+ if ( FILE_Seek( 12 + face->face_index*4 ) ||
+ ACCESS_Frame( 4 ) )
+ goto Exit;
+
+ offset = GET_ULong();
+
+ FORGET_Frame();
+ }
+
+ LOG(( "TrueType offset = %ld\n", offset ));
+
+ if ( FILE_Seek( offset+4 ) ||
+ ACCESS_Frame( 2 ) )
+ goto Exit;
+
+ count = GET_UShort();
+
+ FORGET_Frame();
+
+ if ( FILE_Seek( offset+12 ) ||
+ ACCESS_Frame( count*16 ) )
+ goto Exit;
+
+ for ( nn = 0; nn < count; nn++ )
+ {
+ FT_ULong tag = GET_ULong();
+ FT_ULong checksum = GET_ULong();
+ FT_ULong start = GET_ULong();
+ FT_ULong size = GET_ULong();
+
+ FT_UNUSED(checksum);
+ FT_UNUSED(size);
+
+ if ( tag == the_tag )
+ {
+ LOG(( "TrueType table (start: %ld) (size: %ld)\n", start, size ));
+ error = ftglue_stream_seek( stream, offset+start );
+ goto FoundIt;
+ }
+ }
+ error = TT_Err_Table_Missing;
+
+ FoundIt:
+ FORGET_Frame();
+ }
+
+Exit:
+ LOG(( "TrueType error=%d\n", error ));
+
+ return error;
+}
+
+#undef QALLOC
--- /dev/null
+/* ftglue.c: Glue code for compiling the OpenType code from
+ * FreeType 1 using only the public API of FreeType 2
+ *
+ * By David Turner, The FreeType Project (www.freetype.org)
+ *
+ * This code is explicitely put in the public domain
+ *
+ * ==========================================================================
+ *
+ * the OpenType parser codes was originally written as an extension to
+ * FreeType 1.x. As such, its source code was embedded within the library,
+ * and used many internal FreeType functions to deal with memory and
+ * stream i/o.
+ *
+ * When it was 'salvaged' for Pango and Qt, the code was "ported" to FreeType 2,
+ * which basically means that some macro tricks were performed in order to
+ * directly access FT2 _internal_ functions.
+ *
+ * these functions were never part of FT2 public API, and _did_ change between
+ * various releases. This created chaos for many users: when they upgraded the
+ * FreeType library on their system, they couldn't run Gnome anymore since
+ * Pango refused to link.
+ *
+ * Very fortunately, it's possible to completely avoid this problem because
+ * the FT_StreamRec and FT_MemoryRec structure types, which describe how
+ * memory and stream implementations interface with the rest of the font
+ * library, have always been part of the public API, and never changed.
+ *
+ * What we do thus is re-implement, within the OpenType parser, the few
+ * functions that depend on them. This only adds one or two kilobytes of
+ * code, and ensures that the parser can work with _any_ version
+ * of FreeType installed on your system. How sweet... !
+ *
+ * Note that we assume that Pango doesn't use any other internal functions
+ * from FreeType. It used to in old versions, but this should no longer
+ * be the case. (crossing my fingers).
+ *
+ * - David Turner
+ * - The FreeType Project (www.freetype.org)
+ *
+ * PS: This "glue" code is explicitely put in the public domain
+ */
+#ifndef __OPENTYPE_FTGLUE_H__
+#define __OPENTYPE_FTGLUE_H__
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+FT_BEGIN_HEADER
+
+
+/* utility macros */
+#define TT_Err_Ok FT_Err_Ok
+#define TT_Err_Invalid_Argument FT_Err_Invalid_Argument
+#define TT_Err_Invalid_Face_Handle FT_Err_Invalid_Face_Handle
+#define TT_Err_Table_Missing FT_Err_Table_Missing
+
+#define SET_ERR(c) ( (error = (c)) != 0 )
+
+#ifndef FTGLUE_API
+#define FTGLUE_API(x) extern x
+#endif
+
+#ifndef FTGLUE_APIDEF
+#define FTGLUE_APIDEF(x) x
+#endif
+
+/* stream macros used by the OpenType parser */
+#define FILE_Pos() ftglue_stream_pos( stream )
+#define FILE_Seek(pos) SET_ERR( ftglue_stream_seek( stream, pos ) )
+#define ACCESS_Frame(size) SET_ERR( ftglue_stream_frame_enter( stream, size ) )
+#define FORGET_Frame() ftglue_stream_frame_exit( stream )
+
+#define GET_Byte() ftglue_stream_get_byte( stream )
+#define GET_Short() ftglue_stream_get_short( stream )
+#define GET_Long() ftglue_stream_get_long( stream )
+
+#define GET_Char() ((FT_Char)GET_Byte())
+#define GET_UShort() ((FT_UShort)GET_Short())
+#define GET_ULong() ((FT_ULong)GET_Long())
+#define GET_Tag4() GET_ULong()
+
+FTGLUE_API( FT_Long )
+ftglue_stream_pos( FT_Stream stream );
+
+FTGLUE_API( FT_Error )
+ftglue_stream_seek( FT_Stream stream,
+ FT_Long pos );
+
+FTGLUE_API( FT_Error )
+ftglue_stream_frame_enter( FT_Stream stream,
+ FT_ULong size );
+
+FTGLUE_API( void )
+ftglue_stream_frame_exit( FT_Stream stream );
+
+FTGLUE_API( FT_Byte )
+ftglue_stream_get_byte( FT_Stream stream );
+
+FTGLUE_API( FT_Short )
+ftglue_stream_get_short( FT_Stream stream );
+
+FTGLUE_API( FT_Long )
+ftglue_stream_get_long( FT_Stream stream );
+
+FTGLUE_API( FT_Error )
+ftglue_face_goto_table( FT_Face face,
+ FT_ULong tag,
+ FT_Stream stream );
+
+/* memory macros used by the OpenType parser */
+#define ALLOC(_ptr,_size) \
+ ( (_ptr) = ftglue_alloc( memory, _size, &error ), error != 0 )
+
+#define REALLOC(_ptr,_oldsz,_newsz) \
+ ( (_ptr) = ftglue_realloc( memory, (_ptr), (_oldsz), (_newsz), &error ), error != 0 )
+
+#define FREE(_ptr) \
+ FT_BEGIN_STMNT \
+ if ( (_ptr) ) \
+ { \
+ ftglue_free( memory, _ptr ); \
+ _ptr = NULL; \
+ } \
+ FT_END_STMNT
+
+#define ALLOC_ARRAY(_ptr,_count,_type) \
+ ALLOC(_ptr,(_count)*sizeof(_type))
+
+#define REALLOC_ARRAY(_ptr,_oldcnt,_newcnt,_type) \
+ REALLOC(_ptr,(_oldcnt)*sizeof(_type),(_newcnt)*sizeof(_type))
+
+#define MEM_Copy(dest,source,count) memcpy( (char*)(dest), (const char*)(source), (size_t)(count) )
+
+
+FTGLUE_API( FT_Pointer )
+ftglue_alloc( FT_Memory memory,
+ FT_ULong size,
+ FT_Error *perror );
+
+FTGLUE_API( FT_Pointer )
+ftglue_realloc( FT_Memory memory,
+ FT_Pointer block,
+ FT_ULong old_size,
+ FT_ULong new_size,
+ FT_Error *perror );
+
+FTGLUE_API( void )
+ftglue_free( FT_Memory memory,
+ FT_Pointer block );
+
+/* */
+
+FT_END_HEADER
+
+#endif /* __OPENTYPE_FTGLUE_H__ */
#include "ftxopen.h"
#include "ftxopenf.h"
-#include "fterrcompat.h"
+#include "ftglue.h"
#include FT_TRUETYPE_TAGS_H
-#include FT_INTERNAL_STREAM_H
-#include FT_INTERNAL_MEMORY_H
-#include FT_INTERNAL_TRUETYPE_TYPES_H
-
#define TTAG_GDEF FT_MAKE_TAG( 'G', 'D', 'E', 'F' )
static FT_Error Load_AttachList( TTO_AttachList* al,
FT_Error error;
FT_Memory memory = face->memory;
FT_Stream stream = face->stream;
- TT_Face tt_face = (TT_Face)face;
FT_ULong cur_offset, new_offset, base_offset;
TTO_GDEFHeader* gdef;
if ( !retptr )
return TT_Err_Invalid_Argument;
- if (( error = tt_face->goto_table( tt_face, TTAG_GDEF, stream, NULL ) ))
+ if (( error = ftglue_face_goto_table( face, TTAG_GDEF, stream ) ))
return error;
if (( error = TT_New_GDEF_Table ( face, &gdef ) ))
#include "ftxopen.h"
#include "ftxopenf.h"
-#include "fterrcompat.h"
+#include "ftglue.h"
#include FT_TRUETYPE_TAGS_H
-#include FT_INTERNAL_STREAM_H
-#include FT_INTERNAL_MEMORY_H
-#include FT_INTERNAL_TRUETYPE_TYPES_H
-
#define TTAG_GPOS FT_MAKE_TAG( 'G', 'P', 'O', 'S' )
struct GPOS_Instance_
FT_UShort i, num_lookups;
TTO_GPOSHeader* gpos;
TTO_Lookup* lo;
- TT_Face tt_face = (TT_Face)face;
FT_Stream stream = face->stream;
FT_Error error;
if ( !stream )
return TT_Err_Invalid_Face_Handle;
- if (( error = tt_face->goto_table( tt_face, TTAG_GPOS, stream, NULL ) ))
+ if (( error = ftglue_face_goto_table( face, TTAG_GPOS, stream ) ))
return error;
base_offset = FILE_Pos();
#include "ftxopen.h"
#include "ftxopenf.h"
-#include "fterrcompat.h"
+#include "ftglue.h"
#include FT_TRUETYPE_TAGS_H
-#include FT_INTERNAL_STREAM_H
-#include FT_INTERNAL_MEMORY_H
-#include FT_INTERNAL_TRUETYPE_TYPES_H
-
-
#define GSUB_ID Build_Extension_ID( 'G', 'S', 'U', 'B' )
FT_Memory memory = face->memory;
FT_Error error;
FT_ULong cur_offset, new_offset, base_offset;
- TT_Face tt_face = (TT_Face)face;
FT_UShort i, num_lookups;
TTO_GSUBHeader* gsub;
if ( !retptr )
return TT_Err_Invalid_Argument;
- if (( error = tt_face->goto_table( tt_face, TTAG_GSUB, stream, NULL ) ))
+ if (( error = ftglue_face_goto_table( face, TTAG_GSUB, stream ) ))
return error;
base_offset = FILE_Pos();
#include "ftxopen.h"
#include "ftxopenf.h"
-#include "fterrcompat.h"
-
-#include FT_INTERNAL_STREAM_H
-#include FT_INTERNAL_MEMORY_H
-#include FT_INTERNAL_TRUETYPE_TYPES_H
+#include "ftglue.h"
/***************************
FREE( fr );
}
+
+ FREE( fl->ApplyOrder );
}
*/
#include <otlbuffer.h>
-#include FT_INTERNAL_MEMORY_H
-
/* To get the gcc-3.3 strict-aliasing compatible versions
* FREE/REALLOC_ARRAY/etc. rather than the FT_* versions
* that
*/
-#include "fterrcompat.h"
+#include "ftglue.h"
static FT_Error
otl_buffer_ensure( OTL_Buffer buffer,
*/
#include "pango-ot-private.h"
-#include "fterrcompat.h"
-#include FT_INTERNAL_OBJECTS_H
+#include "ftglue.h"
#include FT_MODULE_H
static void pango_ot_info_class_init (GObjectClass *object_class);
static gboolean
is_truetype (FT_Face face)
{
- return strcmp (FT_MODULE_CLASS (face->driver)->module_name, "truetype") == 0 ||
- strcmp (FT_MODULE_CLASS (face->driver)->module_name, "cff") == 0;
+ return FT_IS_SFNT(face);
}
typedef struct _GlyphInfo GlyphInfo;
#include <pango/pango-ot.h>
#include "pango-ot-private.h"
-#include FT_INTERNAL_MEMORY_H /* For FT_Free() */
-
typedef struct _PangoOTRule PangoOTRule;
struct _PangoOTRule
projects / apps / core / preloaded / video-player.git / commitdiff