/* otfopen.c -- OpenType font reader.
-Copyright (C) 2003
- by AIST (National Institute of Advanced Industrial Science and Technology)
- Registration Number H15PRO???
+Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010
+ National Institute of Advanced Industrial Science and Technology (AIST)
+ Registration Number H15PRO167
-This file is part of the OTF library.
+This file is part of libotf.
-The OTF library is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public License as
-published by the Free Software Foundation; either version 2, or (at
-your option) any later version.
+Libotf is free software; you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
-The OTF library is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-General Public License for more details.
+Libotf is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
+License for more details.
-You should have received a copy of the GNU General Public License
-along with the OTF library; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+You should have received a copy of the GNU Lesser General Public
+License along with this library, in a file named COPYING; if not,
+write to the Free Software Foundation, Inc., 59 Temple Place, Suite
+330, Boston, MA 02111-1307, USA. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <config.h>
#include "otf.h"
-#include "otferror.h"
+#include "internal.h"
+
+#include FT_TRUETYPE_TABLES_H
/***
Table of contents (almost parallel to otf.h):
(1-10) "GPOS" table
(1-11) Structure for OTF
- (2) APIs for reading OTF
+ (2) API for reading OTF
(2-1) OTF_open()
(2-2) OTF_close()
(2-3) OTF_get_table()
+ (2-4) OTF_check_table()
- (5) APIs miscellaneous
+ (5) API miscellaneous
*/
+
+int debug_flag = -1;
+
+static void
+set_debug_flag ()
+{
+ debug_flag = getenv ("LIBOTF_DEBUG") != NULL;
+}
+
\f
/* (0) Stream handler
typedef struct
{
- FILE *fp;
- char *name;
+ const char *name;
long pos;
long bufsize;
long allocated;
typedef long OTF_StreamState;
-OTF_Stream *
-make_stream ()
+static OTF_Stream *
+make_stream (const char *name)
{
OTF_Stream *stream;
char *errfmt = "stream creation%s";
stream = calloc (1, sizeof (OTF_Stream));
if (! stream)
OTF_ERROR (OTF_ERROR_MEMORY, "");
+ stream->name = name;
return stream;
}
-int
-setup_stream (OTF_Stream *stream, FILE *fp, long offset, int nbytes,
- char *name)
+static int
+setup_stream (OTF_Stream *stream, FILE *fp, long offset, int nbytes)
{
char *errfmt = "stream setup for %s";
int errret = -1;
- stream->name = name;
stream->pos = 0;
if (stream->allocated < nbytes)
{
return 0;
}
+static OTF_Stream *
+make_stream_from_ft_face (FT_Face face, const char *name)
+{
+ char *errfmt = "FT_Face stream creation for %s";
+ void *errret = NULL;
+ FT_ULong nbytes = 0;
+ unsigned char *buf;
+ OTF_Stream *stream;
+ FT_ULong tag = FT_MAKE_TAG (name[0], name[1], name[2], name[3]);
-void
+ if (FT_Load_Sfnt_Table (face, tag, 0, NULL, &nbytes))
+ return NULL;
+ buf = malloc (nbytes);
+ if (! buf)
+ OTF_ERROR (OTF_ERROR_MEMORY, name);
+ if (FT_Load_Sfnt_Table (face, tag, 0, buf, &nbytes))
+ {
+ free (buf);
+ OTF_ERROR (OTF_ERROR_FT_FACE, name);
+ }
+ stream = make_stream (name);
+ if (! stream)
+ return NULL;
+ stream->pos = 0;
+ stream->buf = buf;
+ stream->allocated = nbytes;
+ stream->bufsize = nbytes;
+ return stream;
+}
+
+static void
free_stream (OTF_Stream *stream)
{
- free (stream->buf);
+ if (stream->buf)
+ free (stream->buf);
free (stream);
}
(stream)->pos += 2; \
} while (0)
+#define READ_UINT24(stream, var) \
+ do { \
+ STREAM_CHECK_SIZE ((stream), 3); \
+ (var) = (((stream)->buf[(stream)->pos ] << 16) \
+ | ((stream)->buf[(stream)->pos + 1] << 8) \
+ | (stream)->buf[(stream)->pos + 2]); \
+ (stream)->pos += 3; \
+ } while (0)
+
#define READ_ULONG(stream, var) \
do { \
STREAM_CHECK_SIZE ((stream), 4); \
typedef struct OTF_MemoryRecord OTF_MemoryRecord;
-typedef struct
+enum OTF_ReaderFlag
+ {
+ OTF_READ_FULL,
+ OTF_READ_SCRIPTS,
+ OTF_READ_FEATURES,
+ OTF_READ_MAX
+ };
+
+struct _OTF_TableInfo;
+typedef struct _OTF_TableInfo OTF_TableInfo;
+
+struct _OTF_TableInfo
{
/* Points to one of OTF->head, OTF->name, etc. */
void **address;
/* Function to read one of OTF tables. */
- void *(*reader) (OTF *otf, OTF_Stream *stream);
+ void *(*reader) (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag);
/* Stream given to <reader>. */
OTF_Stream *stream;
-} OTF_TableInfo;
+};
+
+struct _OTF_ApplicationData
+{
+ char *id;
+ void *data;
+ void (*freer) (void *data);
+ struct _OTF_ApplicationData *next;
+};
+
+typedef struct _OTF_ApplicationData OTF_ApplicationData;
struct OTF_InternalData
{
/* Records of allocated memories. */
OTF_MemoryRecord *memory_record;
-};
+ /* Root of application data chain. */
+ OTF_ApplicationData *app_data;
+};
static OTF_MemoryRecord *
allocate_memory_record (OTF *otf)
/*** (1-2) "head" table */
static void *
-read_head_table (OTF *otf, OTF_Stream *stream)
+read_head_table (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag)
{
+ OTF_Stream *stream = table->stream;
char *errfmt = "head%s";
void *errret = NULL;
OTF_head *head;
READ_USHORT (stream, head->flags);
READ_USHORT (stream, head->unitsPerEm);
+ *table->address = head;
return head;
}
\f
/*** (1-3) "name" table */
-static char *
-read_name (OTF *otf, OTF_Stream *stream, OTF_NameRecord *rec, int bytes)
+static int
+read_name (OTF *otf, OTF_Stream *stream, OTF_NameRecord *rec)
{
- char *errfmt = "nameID (%d)";
- void *errret = NULL;
+ char errfmt[256];
+ int errret = -1;
OTF_StreamState state;
- char *str;
+ int ucs = 0;
+ int ascii = 0;
int i;
- int c;
+ sprintf (errfmt, "nameID (%d)%%s", rec->nameID);
+ if (rec->platformID == 0)
+ ucs = (rec->encodingID <= 3) ? 2 : 4;
+ else if (rec->platformID == 1 && rec->encodingID == 0)
+ ascii = 1;
+ else if (rec->platformID == 3)
+ ucs = (rec->encodingID == 1 ? 2
+ : rec->encodingID == 10 ? 4
+ : 0);
+
+ OTF_MALLOC (rec->name, rec->length + 1, "");
SAVE_STREAM (stream, state);
SEEK_STREAM (stream, stream->pos + rec->offset);
+ READ_BYTES (stream, rec->name, rec->length);
+ RESTORE_STREAM (stream, state);
+ rec->name[rec->length] = 0;
- if (bytes == 1)
+ if (ascii)
{
- OTF_MALLOC (str, rec->length + 1, (void *) rec->nameID);
- READ_BYTES (stream, str, rec->length);
- for (i = 0; i < rec->length; i++)
- if (str[i] < 0)
- str[i] = '?';
+ rec->ascii = 1;
}
- else if (bytes == 2)
+ else if (ucs == 2)
{
- OTF_MALLOC (str, rec->length / 2 + 1, (void *) rec->nameID);
+ rec->ascii = 1;
for (i = 0; i < rec->length / 2; i++)
{
- READ_USHORT (stream, c);
- if (c >= 128)
- c = '?';
- str[i] = c;
+ if (rec->name[i * 2] > 0
+ || rec->name[i * 2 + 1] >= 128)
+ {
+ rec->ascii = 0;
+ break;
+ }
}
+ if (rec->ascii)
+ for (i = 0; i < rec->length / 2; i++)
+ rec->name[i] = rec->name[i * 2 + 1];
+ rec->name[i] = 0;
}
- else if (bytes == 4)
+ else if (ucs == 4)
{
- OTF_MALLOC (str, rec->length / 4 + 1, (void *) rec->nameID);
+ rec->ascii = 1;
for (i = 0; i < rec->length / 4; i++)
{
- READ_ULONG (stream, c);
- if (c >= 128)
- c = '?';
- str[i] = c;
+ if (rec->name[i * 4] > 0
+ || rec->name[i * 4 + 1] > 0
+ || rec->name[i * 4 + 2] > 0
+ || rec->name[i * 2 + 3] >= 128)
+ {
+ rec->ascii = 0;
+ break;
+ }
}
+ if (rec->ascii)
+ for (i = 0; i < rec->length / 4; i++)
+ rec->name[i] = rec->name[i * 4 + 3];
+ rec->name[i] = 0;
}
- str[i] = '\0';
- RESTORE_STREAM (stream, state);
- return str;
+
+ return 0;
}
static void *
-read_name_table (OTF *otf, OTF_Stream *stream)
+read_name_table (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag)
{
+ OTF_Stream *stream = table->stream;
char *errfmt = "name%s";
void *errret = NULL;
OTF_name *name;
OTF_NameRecord *rec = name->nameRecord + i;
int nameID = rec->nameID;
- if (nameID <= OTF_max_nameID
- && ! name->name[nameID])
- {
- if (rec->platformID == 0)
- name->name[nameID] = read_name (otf, stream, rec,
- rec->encodingID <= 3 ? 2 : 4);
- else if (rec->platformID == 1
- && rec->encodingID == 0)
- name->name[nameID] = read_name (otf, stream, rec, 1);
- else if (rec->platformID == 3
- && (rec->encodingID == 1 || rec->encodingID == 10))
- name->name[nameID] = read_name (otf, stream,
- rec, rec->encodingID == 1 ? 2 : 4);
- }
+ read_name (otf, stream, rec);
+
+ if (nameID >= OTF_max_nameID)
+ continue;
+ if (! name->name[nameID]
+ && rec->ascii)
+ name->name[nameID] = (char *) rec->name;
}
+ *table->address = name;
return name;
}
\f
/*** (1-4) "cmap" table */
+static OTF_EncodingSubtable14 *
+read_cmap_uvs_table (OTF *otf, OTF_Stream *stream, OTF_Offset offset)
+{
+ OTF_EncodingSubtable14 *sub14;
+ char *errfmt = "cmap-uvs%s";
+ void *errret = NULL;
+ unsigned nRecords;
+ unsigned i,j;
+
+ OTF_MALLOC (sub14, 1, " (EncodingSubtable14)");
+ READ_ULONG (stream, nRecords);
+ sub14->nRecords = nRecords;
+ OTF_MALLOC (sub14->Records, nRecords, "(EncodingSubtable14-Records)");
+ for (i = 0; i < sub14->nRecords; i++)
+ {
+ unsigned varSelector=0, defaultUVSOffset, nonDefaultUVSOffset;
+
+ READ_UINT24 (stream, varSelector);
+ sub14->Records[i].varSelector = varSelector;
+ READ_ULONG (stream, defaultUVSOffset);
+ sub14->Records[i].defaultUVSOffset = defaultUVSOffset;
+ READ_ULONG (stream, nonDefaultUVSOffset);
+ sub14->Records[i].nonDefaultUVSOffset = nonDefaultUVSOffset;
+ }
+ for (i = 0; i < sub14->nRecords; i++)
+ {
+ OTF_VariationSelectorRecord *record = &sub14->Records[i];
+ unsigned defaultUVSOffset = record->defaultUVSOffset;
+ unsigned nonDefaultUVSOffset = record->nonDefaultUVSOffset;
+
+ if (defaultUVSOffset)
+ {
+ unsigned numUnicodeValueRanges;
+
+ SEEK_STREAM (stream, offset+defaultUVSOffset);
+ READ_ULONG (stream, numUnicodeValueRanges);
+ record->numUnicodeValueRanges = numUnicodeValueRanges;
+ OTF_MALLOC (record->unicodeValueRanges,
+ numUnicodeValueRanges,
+ "(EncodingSubtable14-Records-unicodeValueRanges)");
+ for (j = 0; j < numUnicodeValueRanges; j++)
+ {
+ OTF_UnicodeValueRange *unicodeValueRange
+ = &record->unicodeValueRanges[j];
+ unsigned startUnicodeValue;
+ char additionalCount;
+
+ READ_UINT24 (stream, startUnicodeValue);
+ unicodeValueRange->startUnicodeValue=startUnicodeValue;
+ READ_BYTES (stream, &additionalCount, 1);
+ unicodeValueRange->additionalCount
+ = (unsigned short) additionalCount;
+ }
+ }
+ if (nonDefaultUVSOffset)
+ {
+ unsigned numUVSMappings;
+
+ SEEK_STREAM (stream, offset+nonDefaultUVSOffset);
+ READ_ULONG (stream, numUVSMappings);
+ record->numUVSMappings = numUVSMappings;
+ OTF_MALLOC (record->uvsMappings, numUVSMappings,
+ "(EncodingSubtable14-Records-uvsMappings)");
+ for (j = 0; j < numUVSMappings; j++)
+ {
+ OTF_UVSMapping *uvsMapping = &record->uvsMappings[j];
+ unsigned unicodeValue;
+ unsigned short glyphID;
+
+ READ_UINT24 (stream, unicodeValue);
+ uvsMapping->unicodeValue = unicodeValue;
+ READ_USHORT (stream, glyphID);
+ uvsMapping->glyphID = glyphID;
+ }
+ }
+ }
+ return sub14;
+}
+
static void *
-read_cmap_table (OTF *otf, OTF_Stream *stream)
+read_cmap_table (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag)
{
+ OTF_Stream *stream = table->stream;
char *errfmt = "cmap%s";
void *errret = NULL;
OTF_cmap *cmap;
+ int unicode_bmp_index = -1, unicode_full_index = -1;
int i;
OTF_CALLOC (cmap, 1, "");
OTF_MALLOC (cmap->EncodingRecord, cmap->numTables, "");
for (i = 0; i < cmap->numTables; i++)
{
- READ_USHORT (stream, cmap->EncodingRecord[i].platformID);
- READ_USHORT (stream, cmap->EncodingRecord[i].encodingID);
+ unsigned platformID, encodingID;
+
+ READ_USHORT (stream, platformID);
+ cmap->EncodingRecord[i].platformID = platformID;
+ READ_USHORT (stream, encodingID);
+ cmap->EncodingRecord[i].encodingID = encodingID;
READ_ULONG (stream, cmap->EncodingRecord[i].offset);
- if (cmap->EncodingRecord[i].platformID == 3
- && cmap->EncodingRecord[i].encodingID == 1)
- cmap->Unicode = cmap->EncodingRecord + i;
+ if (platformID == 0)
+ {
+ if (encodingID <= 3)
+ unicode_bmp_index = i;
+ else
+ unicode_full_index = i;
+ }
+ else if (platformID == 3)
+ {
+ if (encodingID == 1)
+ unicode_bmp_index = i;
+ else if (encodingID == 10)
+ unicode_full_index = i;
+ }
}
+ cmap->table_index = unicode_full_index;
+
for (i = 0; i < cmap->numTables; i++)
{
unsigned format;
SEEK_STREAM (stream, cmap->EncodingRecord[i].offset);
READ_USHORT (stream, format);
cmap->EncodingRecord[i].subtable.format = format;
- READ_USHORT (stream, cmap->EncodingRecord[i].subtable.length);
- if (format == 8 || format == 10 || format == 12)
+ if (format == 14)
{
READ_ULONG (stream, cmap->EncodingRecord[i].subtable.length);
- READ_ULONG (stream, cmap->EncodingRecord[i].subtable.language);
+ cmap->EncodingRecord[i].subtable.language = 0;
}
else
{
- READ_USHORT (stream, cmap->EncodingRecord[i].subtable.language);
+ READ_USHORT (stream, cmap->EncodingRecord[i].subtable.length);
+ if (format == 8 || format == 10 || format == 12)
+ {
+ READ_ULONG (stream, cmap->EncodingRecord[i].subtable.length);
+ READ_ULONG (stream, cmap->EncodingRecord[i].subtable.language);
+ }
+ else
+ {
+ READ_USHORT (stream, cmap->EncodingRecord[i].subtable.language);
+ }
}
switch (format)
{
break;
case 2:
+ {
+ OTF_EncodingSubtable2 *sub2;
+ int j, max_key;
+
+ OTF_MALLOC (sub2, 1, " (EncodingSubtable2)");
+ cmap->EncodingRecord[i].subtable.f.f2 = sub2;
+ for (j = 0, max_key = 0; j < 256; j++)
+ {
+ READ_USHORT (stream, sub2->subHeaderKeys[j]);
+ if (max_key < sub2->subHeaderKeys[j])
+ max_key = sub2->subHeaderKeys[j];
+ }
+ max_key += 8;
+ sub2->subHeaderCount = max_key / 8;
+ OTF_MALLOC (sub2->subHeaders, max_key / 8, " (subHeaders)");
+ for (j = 0; j < sub2->subHeaderCount; j++)
+ {
+ READ_USHORT (stream, sub2->subHeaders[j].firstCode);
+ READ_USHORT (stream, sub2->subHeaders[j].entryCount);
+ READ_SHORT (stream, sub2->subHeaders[j].idDelta);
+ READ_USHORT (stream, sub2->subHeaders[j].idRangeOffset);
+ /* Make it offset from sub2->glyphIndexArray. */
+ sub2->subHeaders[j].idRangeOffset -= max_key - (j * 8 + 6);
+ }
+ sub2->glyphIndexCount = (cmap->EncodingRecord[i].subtable.length
+ - 262 - max_key);
+ OTF_MALLOC (sub2->glyphIndexArray, sub2->glyphIndexCount,
+ " (glyphIndexArray)");
+ READ_BYTES (stream, sub2->glyphIndexArray, sub2->glyphIndexCount);
+ }
break;
case 4:
{
unsigned off;
unsigned rest = 2 * (segCount - j);
-
+
READ_USHORT (stream, off);
if (off == 0)
sub4->segments[j].idRangeOffset = 0xFFFF;
for (j = 0; j < sub4->GlyphCount; j++)
READ_USHORT (stream, sub4->glyphIdArray[j]);
}
+ break;
+
+ case 6:
+ {
+ OTF_EncodingSubtable6 *sub6;
+ int j;
+
+ OTF_MALLOC (sub6, 1, " (EncodingSubtable6)");
+ cmap->EncodingRecord[i].subtable.f.f6 = sub6;
+ READ_USHORT (stream, sub6->firstCode);
+ READ_USHORT (stream, sub6->entryCount);
+ OTF_MALLOC (sub6->glyphIdArray, sub6->entryCount, " (GlyphCount)");
+ for (j = 0; j < sub6->entryCount; j++)
+ READ_USHORT (stream, sub6->glyphIdArray[j]);
+ }
+ break;
+
+ case 8:
+ {
+ OTF_EncodingSubtable8 *sub8;
+ int j;
+
+ OTF_MALLOC (sub8, 1, " (EncodingSubtable8)");
+ cmap->EncodingRecord[i].subtable.f.f8 = sub8;
+ for (j = 0; j < 8192; j++)
+ READ_BYTES (stream, sub8->is32, 8192);
+ READ_ULONG (stream, sub8->nGroups);
+ OTF_MALLOC (sub8->Groups, sub8->nGroups, " (Groups)");
+ for (j = 0; j < sub8->nGroups; j++)
+ {
+ READ_ULONG (stream, sub8->Groups[i].startCharCode);
+ READ_ULONG (stream, sub8->Groups[i].endCharCode);
+ READ_ULONG (stream, sub8->Groups[i].startGlyphID);
+ }
+ }
+ break;
+
+ case 10:
+ {
+ OTF_EncodingSubtable10 *sub10;
+ int j;
+
+ OTF_MALLOC (sub10, 1, " (EncodingSubtable10)");
+ cmap->EncodingRecord[i].subtable.f.f10 = sub10;
+ READ_ULONG (stream, sub10->startCharCode);
+ READ_ULONG (stream, sub10->numChars);
+ OTF_MALLOC (sub10->glyphs, sub10->numChars, " (GlyphCount)");
+ for (j = 0; j < sub10->numChars; j++)
+ READ_USHORT (stream, sub10->glyphs[j]);
+ }
+ break;
+
+ case 12:
+ {
+ OTF_EncodingSubtable12 *sub12;
+ int j;
+
+ OTF_MALLOC (sub12, 1, " (EncodingSubtable12)");
+ cmap->EncodingRecord[i].subtable.f.f12 = sub12;
+ READ_ULONG (stream, sub12->nGroups);
+ OTF_MALLOC (sub12->Groups, sub12->nGroups, " (Groups)");
+ for (j = 0; j < sub12->nGroups; j++)
+ {
+ READ_ULONG (stream, sub12->Groups[j].startCharCode);
+ READ_ULONG (stream, sub12->Groups[j].endCharCode);
+ READ_ULONG (stream, sub12->Groups[j].startGlyphID);
+ }
+ }
+ break;
+
+ case 14:
+ {
+ cmap->EncodingRecord[i].subtable.f.f14
+ = read_cmap_uvs_table (otf, stream,
+ cmap->EncodingRecord[i].offset);
+ break;
+ }
+
+ default:
+ OTF_ERROR (OTF_ERROR_TABLE, " (invalid Subtable format)");
+ }
+ }
+
+ if (unicode_bmp_index >= 0)
+ {
+ OTF_EncodingRecord *rec = cmap->EncodingRecord + unicode_bmp_index;
+ OTF_GlyphID glyph_id, max_glyph_id = 0;
+
+ OTF_CALLOC (cmap->unicode_table, 0x10000, "");
+ switch (rec->subtable.format)
+ {
+ case 4:
+ {
+ OTF_EncodingSubtable4 *sub4 = rec->subtable.f.f4;
+ int segCount = sub4->segCountX2 / 2;
+
+ for (i = 0; i < segCount; i++)
+ {
+ OTF_cmapSegment *seg = sub4->segments + i;
+ int c;
+
+ if (seg->idRangeOffset == 0xFFFF)
+ for (c = seg->startCount; c <= seg->endCount; c++)
+ {
+ glyph_id = (c + seg->idDelta) % 0x10000;
+ cmap->unicode_table[c] = glyph_id;
+ if (glyph_id > max_glyph_id)
+ max_glyph_id = glyph_id;
+ }
+ else
+ for (c = seg->startCount; c <= seg->endCount && c != 0xFFFF;
+ c++)
+ {
+ glyph_id = sub4->glyphIdArray[seg->idRangeOffset
+ + (c - seg->startCount)];
+ cmap->unicode_table[c] = glyph_id;
+ if (glyph_id > max_glyph_id)
+ max_glyph_id = glyph_id;
+ }
+ }
+ }
}
+
+ OTF_CALLOC (cmap->decode_table, max_glyph_id + 1, "");
+ for (i = 0; i < 0x10000; i++)
+ if (cmap->unicode_table[i])
+ cmap->decode_table[cmap->unicode_table[i]] = i;
+ cmap->max_glyph_id = max_glyph_id;
}
+
+ *table->address = cmap;
return cmap;
}
READ_GLYPHID (stream, (*ids)[i]);
return count;
}
-
+
static unsigned
read_range_records (OTF *otf, OTF_Stream *stream, OTF_RangeRecord **record)
{
int errret = -1;
OTF_StreamState state;
int count;
-
+
READ_OFFSET (stream, coverage->offset);
SAVE_STREAM (stream, state);
SEEK_STREAM (stream, offset + coverage->offset);
char *errfmt = "ClassDef%s";
int errret = -1;
OTF_StreamState state;
-
+
READ_OFFSET (stream, class->offset);
if (! class->offset)
return 0;
READ_UINT16 (stream, table->EndSize);
READ_UINT16 (stream, table->DeltaFormat);
num = table->EndSize - table->StartSize + 1;
- OTF_MALLOC (table->DeltaValue, num, "");
+ if (num > 0 && table->DeltaFormat >= 1 && table->DeltaFormat <= 3)
+ {
+ OTF_MALLOC (table->DeltaValue, num, "");
- if (table->DeltaFormat == 1)
- for (i = 0; i < num; i++)
- {
- if ((i % 8) == 0)
- READ_UINT16 (stream, val);
- intval.int2 = (val >> (14 - (i % 8) * 2)) & 0x03;
- table->DeltaValue[i] = intval.int2;
- }
- else if (table->DeltaFormat == 2)
- for (i = 0; i < num; i++)
- {
- if ((i % 4) == 0)
- READ_UINT16 (stream, val);
- intval.int4 = (val >> (12 - (i % 4) * 4)) & 0x0F;
- table->DeltaValue[i] = intval.int4;
- }
- else if (table->DeltaFormat == 3)
- for (i = 0; i < num; i++)
- {
- if ((i % 2) == 0)
+ if (table->DeltaFormat == 1)
+ for (i = 0; i < num; i++)
{
- READ_UINT16 (stream, val);
- intval.int8 = val >> 8;
- table->DeltaValue[i] = intval.int8;
+ if ((i % 8) == 0)
+ READ_UINT16 (stream, val);
+ intval.int2 = (val >> (14 - (i % 8) * 2)) & 0x03;
+ table->DeltaValue[i] = intval.int2;
}
- else
+ else if (table->DeltaFormat == 2)
+ for (i = 0; i < num; i++)
{
- intval.int8 = val >> 8;
- table->DeltaValue[i] = intval.int8;
+ if ((i % 4) == 0)
+ READ_UINT16 (stream, val);
+ intval.int4 = (val >> (12 - (i % 4) * 4)) & 0x0F;
+ table->DeltaValue[i] = intval.int4;
}
- }
+ else /* (table->DeltaFormat == 3) */
+ for (i = 0; i < num; i++)
+ {
+ if ((i % 2) == 0)
+ {
+ READ_UINT16 (stream, val);
+ intval.int8 = val >> 8;
+ table->DeltaValue[i] = intval.int8;
+ }
+ else
+ {
+ intval.int8 = val >> 8;
+ table->DeltaValue[i] = intval.int8;
+ }
+ }
+ }
else
- OTF_ERROR (OTF_ERROR_TABLE, " (Invalid format)");
+ {
+ /* Invalid DeltaFormat but several fonts has such values (bug of
+ fontforge?). So accept it with NULL delta values. */
+ table->DeltaValue = NULL;
+ }
return 0;
}
}
static void *
-read_gdef_table (OTF *otf, OTF_Stream *stream)
+read_gdef_table (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag)
{
+ OTF_Stream *stream = table->stream;
char *errfmt = "GDEF%s";
void *errret = NULL;
OTF_GDEF *gdef;
OTF_CALLOC (gdef, 1, "");
- read_gdef_header (stream, (OTF_GDEFHeader *) &gdef->header);
- if (gdef->header.GlyphClassDef)
+ if (stream->buf)
{
- gdef->glyph_class_def.offset = gdef->header.GlyphClassDef;
- read_class_def_without_offset (otf, stream, &gdef->glyph_class_def);
- }
- if (gdef->header.AttachList)
- read_attach_list (otf, stream, gdef->header.AttachList,
- &gdef->attach_list);
- if (gdef->header.LigCaretList)
- read_lig_caret_list (otf, stream, gdef->header.LigCaretList,
- &gdef->lig_caret_list);
- if (gdef->header.MarkAttachClassDef)
- {
- gdef->mark_attach_class_def.offset = gdef->header.MarkAttachClassDef;
- read_class_def_without_offset (otf, stream, &gdef->mark_attach_class_def);
+ read_gdef_header (stream, (OTF_GDEFHeader *) &gdef->header);
+ if (gdef->header.GlyphClassDef)
+ {
+ gdef->glyph_class_def.offset = gdef->header.GlyphClassDef;
+ read_class_def_without_offset (otf, stream,
+ &gdef->glyph_class_def);
+ }
+ if (gdef->header.AttachList)
+ read_attach_list (otf, stream, gdef->header.AttachList,
+ &gdef->attach_list);
+ if (gdef->header.LigCaretList)
+ read_lig_caret_list (otf, stream, gdef->header.LigCaretList,
+ &gdef->lig_caret_list);
+ if (gdef->header.MarkAttachClassDef)
+ {
+ gdef->mark_attach_class_def.offset = gdef->header.MarkAttachClassDef;
+ read_class_def_without_offset (otf, stream,
+ &gdef->mark_attach_class_def);
+ }
}
+ *table->address = gdef;
return gdef;
}
for (k = 0; k < langsys->FeatureCount; k++)
READ_USHORT (stream, langsys->FeatureIndex[k]);
}
-
+
for (j = 0; j < script->LangSysCount; j++)
{
OTF_LangSys *langsys = script->LangSys + j;
int errret = -1;
int i, j;
+ SEEK_STREAM (stream, offset);
READ_UINT16 (stream, list->FeatureCount);
OTF_CALLOC (list->Feature, list->FeatureCount, "");
for (i = 0; i < list->FeatureCount; i++)
READ_UINT16 (stream, count);
if (! count)
OTF_ERROR (OTF_ERROR_TABLE, " (zero count)");
- OTF_MALLOC (*set, count, "");
+ OTF_CALLOC (*set, count, "");
for (i = 0; i < count; i++)
/* Offset can be zero. */
READ_OFFSET (stream, (*set)[i].offset);
= read_glyph_ids (otf, stream,
(OTF_GlyphID **) &(*rule)[i].LookAhead, 0, -1);
(*rule)[i].LookupCount
- = read_lookup_record_list (otf, stream,
+ = read_lookup_record_list (otf, stream,
&(*rule)[i].LookupRecord, -1);
if (! (*rule)[i].LookupCount)
return errret;
}
static void *
-read_gsub_gpos_table (OTF *otf, OTF_Stream *stream, int gsubp)
+read_gsub_gpos_table (OTF *otf, OTF_TableInfo *table, int gsubp,
+ enum OTF_ReaderFlag flag)
{
+ OTF_Stream *stream = table->stream;
char *errfmt = gsubp ? "GSUB%s" : "GPOS%s";
void *errret = NULL;
- OTF_GSUB_GPOS *gsub_gpos;
-
- OTF_CALLOC (gsub_gpos, 1, "");
- READ_FIXED (stream, gsub_gpos->Version);
- READ_OFFSET (stream, gsub_gpos->ScriptList.offset);
- READ_OFFSET (stream, gsub_gpos->FeatureList.offset);
- READ_OFFSET (stream, gsub_gpos->LookupList.offset);
-
- if (read_script_list (otf, stream, gsub_gpos->ScriptList.offset,
- &gsub_gpos->ScriptList) < 0
- || read_feature_list (otf, stream, gsub_gpos->FeatureList.offset,
- &gsub_gpos->FeatureList) < 0
- || read_lookup_list (otf, stream, gsub_gpos->LookupList.offset,
- &gsub_gpos->LookupList, gsubp) < 0)
+ OTF_GSUB_GPOS *gsub_gpos = *table->address;
+
+ if (gsub_gpos)
+ SEEK_STREAM (stream, 10);
+ else
+ {
+ SEEK_STREAM (stream, 0);
+ OTF_CALLOC (gsub_gpos, 1, "");
+ READ_FIXED (stream, gsub_gpos->Version);
+ READ_OFFSET (stream, gsub_gpos->ScriptList.offset);
+ READ_OFFSET (stream, gsub_gpos->FeatureList.offset);
+ READ_OFFSET (stream, gsub_gpos->LookupList.offset);
+ *table->address = gsub_gpos;
+ }
+
+ if (! gsub_gpos->ScriptList.Script
+ && read_script_list (otf, stream, gsub_gpos->ScriptList.offset,
+ &gsub_gpos->ScriptList) < 0)
return NULL;
+ if (flag != OTF_READ_SCRIPTS)
+ {
+ if (! gsub_gpos->FeatureList.Feature
+ && read_feature_list (otf, stream, gsub_gpos->FeatureList.offset,
+ &gsub_gpos->FeatureList) < 0)
+ return NULL;
+ if (flag != OTF_READ_FEATURES)
+ {
+ if (! gsub_gpos->LookupList.Lookup
+ && read_lookup_list (otf, stream, gsub_gpos->LookupList.offset,
+ &gsub_gpos->LookupList, gsubp) < 0)
+ return NULL;
+ }
+ }
+
return gsub_gpos;
}
OTF_AlternateSet **altset)
{
char *errfmt = "AlternateSet%s";
- int errret = -1;
+ int errret = 0;
unsigned count;
int i;
return count;
}
-static int
+static int
+read_reverse_chain1 (OTF *otf, OTF_Stream *stream, long offset,
+ OTF_Coverage *coverage,
+ OTF_GSUB_ReverseChain1 *reverse_chain)
+{
+ int count;
+
+ if (read_coverage (otf, stream, offset, coverage) < 0)
+ return -1;
+ count = read_coverage_list (otf, stream, offset,
+ &reverse_chain->Backtrack, -1);
+ if (count < 0)
+ return -1;
+ reverse_chain->BacktrackGlyphCount = (unsigned) count;
+ count = read_coverage_list (otf, stream, offset,
+ &reverse_chain->LookAhead, -1);
+ if (count <= 0)
+ return -1;
+ reverse_chain->LookaheadGlyphCount = (unsigned) count;
+ count = read_glyph_ids (otf, stream, &reverse_chain->Substitute, 0, -1);
+ if (count <= 0)
+ return -1;
+ reverse_chain->GlyphCount = count;
+ return 0;
+}
+
+static int
read_lookup_subtable_gsub (OTF *otf, OTF_Stream *stream, long offset,
unsigned type, OTF_LookupSubTableGSUB *subtable)
{
int errret = -1;
SEEK_STREAM (stream, offset);
- READ_UINT16 (stream, subtable->Format);
+ READ_USHORT (stream, subtable->Format);
sprintf (errfmt, "GSUB Lookup %d-%d%%s", type, subtable->Format);
switch (type)
{
else
OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
-
+
case 3:
if (subtable->Format == 1)
{
else
OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
-
+
case 6:
if (subtable->Format == 1)
{
else
OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
-
+
case 7:
+ if (subtable->Format == 1)
+ {
+ unsigned ex_type;
+ long ex_offset;
+ OTF_LookupSubTableGSUB *ex_subtable;
+
+ READ_USHORT (stream, ex_type);
+ READ_ULONG (stream, ex_offset);
+ OTF_CALLOC (ex_subtable, 1, " (SubTable)");
+ if (read_lookup_subtable_gsub (otf, stream, offset + ex_offset,
+ ex_type, ex_subtable) < 0)
+ return errret;
+ subtable->u.extension1.ExtensionLookupType = ex_type;
+ subtable->u.extension1.ExtensionOffset = ex_offset;
+ subtable->u.extension1.ExtensionSubtable = ex_subtable;
+ }
+ else
+ OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
+ break;
+
case 8:
- OTF_ERROR (OTF_ERROR_TABLE, " (not yet supported)");
+ if (subtable->Format == 1)
+ {
+ if (read_reverse_chain1 (otf, stream, offset, &subtable->Coverage,
+ &subtable->u.reverse_chain1) < 0)
+ return errret;
+ }
+ else
+ OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
default:
}
static void *
-read_gsub_table (OTF *otf, OTF_Stream *stream)
+read_gsub_table (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag)
{
- return read_gsub_gpos_table (otf, stream, 1);
+ return read_gsub_gpos_table (otf, table, 1, flag);
}
\f
OTF_StreamState state;
int size, i;
+ memset (value_record, 0, sizeof (OTF_ValueRecord));
if (! bit)
return 0;
for (i = 0, size = 0; i < 8; i++)
if (bit & OTF_XPlacement)
READ_INT16 (stream, value_record->XPlacement);
- if (bit & OTF_XPlacement)
+ if (bit & OTF_YPlacement)
READ_INT16 (stream, value_record->YPlacement);
if (bit & OTF_XAdvance)
READ_INT16 (stream, value_record->XAdvance);
int errret = -1;
OTF_StreamState state;
int i;
-
+
READ_OFFSET (stream, array->offset);
SAVE_STREAM (stream, state);
SEEK_STREAM (stream, offset + array->offset);
int errret = -1;
OTF_StreamState state;
int i, j;
-
+
READ_OFFSET (stream, array->offset);
SAVE_STREAM (stream, state);
SEEK_STREAM (stream, offset + array->offset);
}
for (i = 0; i < array->Count; i++)
for (j = 0; j < ClassCount; j++)
- if (read_anchor (otf, stream, offset + array->offset,
- &array->AnchorRecord[i].Anchor[j]) < 0)
+ if (array->AnchorRecord[i].Anchor[j].offset > 0
+ && read_anchor (otf, stream, offset + array->offset,
+ &array->AnchorRecord[i].Anchor[j]) < 0)
return -1;
RESTORE_STREAM (stream, state);
return 0;
}
+static OTF_PairSet *
+read_pair_set_list (OTF *otf, OTF_Stream *stream, long offset, unsigned num,
+ enum OTF_ValueFormat bit1, enum OTF_ValueFormat bit2)
+{
+ char *errfmt = "PairSet%s";
+ void *errret = NULL;
+ OTF_StreamState state;
+ OTF_PairSet *set;
+ int i, j;
+
+ OTF_MALLOC (set, num, "");
+ for (i = 0; i < num; i++)
+ READ_OFFSET (stream, set[i].offset);
+ SAVE_STREAM (stream, state);
+ for (i = 0; i < num; i++)
+ {
+ SEEK_STREAM (stream, offset + set[i].offset);
+ READ_UINT16 (stream, set[i].PairValueCount);
+ OTF_MALLOC (set[i].PairValueRecord, set[i].PairValueCount, "");
+ for (j = 0; j < set[i].PairValueCount; j++)
+ {
+ OTF_PairValueRecord *rec = set[i].PairValueRecord + j;
+
+ READ_UINT16 (stream, rec->SecondGlyph);
+ read_value_record (otf, stream, offset, bit1, &rec->Value1);
+ read_value_record (otf, stream, offset, bit2, &rec->Value2);
+ }
+ }
+ RESTORE_STREAM (stream, state);
+ return set;
+}
static OTF_Class1Record *
read_class1_record_list (OTF *otf, OTF_Stream *stream, long offset,
return rec;
}
-static int
-read_lookup_subtable_gpos (OTF *otf, OTF_Stream *stream,
- long offset, unsigned type,
- OTF_LookupSubTableGPOS *subtable)
+static unsigned
+read_entry_exit_list (OTF *otf, OTF_Stream *stream, long offset,
+ OTF_EntryExitRecord **rec)
{
- char errfmt[256];
+ char *errfmt = "EntryExitSet%s";
+ int errret = 0;
+ unsigned count;
+ int i;
+ OTF_StreamState state;
+
+ READ_UINT16 (stream, count);
+ if (! count)
+ OTF_ERROR (OTF_ERROR_TABLE, " (zero count)");
+ OTF_MALLOC (*rec, count, "");
+ for (i = 0; i < count; i++)
+ {
+ READ_OFFSET (stream, (*rec)[i].EntryAnchor.offset);
+ READ_OFFSET (stream, (*rec)[i].ExitAnchor.offset);
+ }
+ SAVE_STREAM (stream, state);
+ for (i = 0; i < count; i++)
+ {
+ if (read_anchor (otf, stream, offset, &(*rec)[i].EntryAnchor) < 0)
+ return -1;
+ if (read_anchor (otf, stream, offset, &(*rec)[i].ExitAnchor) < 0)
+ return -1;
+ }
+ RESTORE_STREAM (stream, state);
+ return count;
+}
+
+static int
+read_ligature_attach (OTF *otf, OTF_Stream *stream, long offset,
+ unsigned ClassCount, OTF_LigatureAttach *attach)
+{
+ char *errfmt = "LigatureAttach%s";
int errret = -1;
+ int i, j;
- SEEK_STREAM (stream, offset);
- READ_UINT16 (stream, subtable->Format);
- sprintf (errfmt, "GPOS Lookup %d-%d%%s", type, subtable->Format);
- switch (type)
+ SEEK_STREAM (stream, offset + attach->offset);
+ READ_UINT16 (stream, attach->ComponentCount);
+ OTF_MALLOC (attach->ComponentRecord, attach->ComponentCount, "");
+ for (i = 0; i < attach->ComponentCount; i++)
+ {
+ OTF_MALLOC (attach->ComponentRecord[i].LigatureAnchor, ClassCount,
+ " (ComponentRecord)");
+ for (j = 0; j < ClassCount; j++)
+ READ_OFFSET (stream,
+ attach->ComponentRecord[i].LigatureAnchor[j].offset);
+ }
+ for (i = 0; i < attach->ComponentCount; i++)
+ for (j = 0; j < ClassCount; j++)
+ {
+ if (attach->ComponentRecord[i].LigatureAnchor[j].offset)
+ {
+ if (read_anchor (otf, stream, offset + attach->offset,
+ &attach->ComponentRecord[i].LigatureAnchor[j]) < 0)
+ return -1;
+ }
+ else
+ attach->ComponentRecord[i].LigatureAnchor[j].AnchorFormat = 0;
+ }
+ return 0;
+}
+
+static int
+read_ligature_array (OTF *otf, OTF_Stream *stream, long offset,
+ unsigned class_count, OTF_LigatureArray *array)
+{
+ char *errfmt = "LigatureArray%s";
+ int errret = -1;
+ OTF_StreamState state;
+ int i;
+
+ READ_OFFSET (stream, array->offset);
+ SAVE_STREAM (stream, state);
+ SEEK_STREAM (stream, offset + array->offset);
+ READ_UINT16 (stream, array->LigatureCount);
+ OTF_MALLOC (array->LigatureAttach, array->LigatureCount, "");
+ for (i = 0; i < array->LigatureCount; i++)
+ READ_OFFSET (stream, array->LigatureAttach[i].offset);
+ for (i = 0; i < array->LigatureCount; i++)
+ if (array->LigatureAttach[i].offset > 0
+ && read_ligature_attach (otf, stream, offset + array->offset,
+ class_count, array->LigatureAttach + i) < 0)
+ return -1;
+ RESTORE_STREAM (stream, state);
+ return 0;
+}
+
+static int
+read_lookup_subtable_gpos (OTF *otf, OTF_Stream *stream,
+ long offset, unsigned type,
+ OTF_LookupSubTableGPOS *subtable)
+{
+ char errfmt[256];
+ int errret = -1;
+
+ SEEK_STREAM (stream, offset);
+ READ_UINT16 (stream, subtable->Format);
+ sprintf (errfmt, "GPOS Lookup %d-%d%%s", type, subtable->Format);
+ switch (type)
{
case 1:
if (subtable->Format == 1)
{
+ if (read_coverage (otf, stream, offset, &subtable->Coverage) < 0)
+ return -1;
READ_UINT16 (stream, subtable->u.single1.ValueFormat);
read_value_record (otf, stream, offset,
subtable->u.single1.ValueFormat,
OTF_GPOS_Single2 *single2 = &subtable->u.single2;
int i;
+ if (read_coverage (otf, stream, offset, &subtable->Coverage) < 0)
+ return -1;
READ_UINT16 (stream, single2->ValueFormat);
READ_UINT16 (stream, single2->ValueCount);
OTF_CALLOC (single2->Value, single2->ValueCount," (ValueRecord)");
case 2:
if (subtable->Format == 1)
{
- OTF_ERROR (OTF_ERROR_TABLE, " (not yet supported)");
+ if (read_coverage (otf, stream, offset, &subtable->Coverage) < 0)
+ return -1;
+ READ_UINT16 (stream, subtable->u.pair1.ValueFormat1);
+ READ_UINT16 (stream, subtable->u.pair1.ValueFormat2);
+ READ_UINT16 (stream, subtable->u.pair1.PairSetCount);
+ subtable->u.pair1.PairSet
+ = read_pair_set_list (otf, stream, offset,
+ subtable->u.pair1.PairSetCount,
+ subtable->u.pair1.ValueFormat1,
+ subtable->u.pair1.ValueFormat2);
+ if (! subtable->u.pair1.PairSet)
+ return -1;
}
else if (subtable->Format == 2)
{
- SEEK_STREAM (stream, offset + 2);
- read_coverage (otf, stream, offset, &subtable->Coverage);
+ if (read_coverage (otf, stream, offset, &subtable->Coverage) < 0)
+ return -1;
READ_UINT16 (stream, subtable->u.pair2.ValueFormat1);
READ_UINT16 (stream, subtable->u.pair2.ValueFormat2);
- read_class_def (otf, stream, offset,
- &subtable->u.pair2.ClassDef1);
- read_class_def (otf, stream, offset,
- &subtable->u.pair2.ClassDef2);
+ if (read_class_def (otf, stream, offset,
+ &subtable->u.pair2.ClassDef1) < 0
+ || read_class_def (otf, stream, offset,
+ &subtable->u.pair2.ClassDef2) < 0)
+ return -1;
READ_UINT16 (stream, subtable->u.pair2.Class1Count);
READ_UINT16 (stream, subtable->u.pair2.Class2Count);
subtable->u.pair2.Class1Record
subtable->u.pair2.ValueFormat1,
subtable->u.pair2.Class2Count,
subtable->u.pair2.ValueFormat2);
+ if (! subtable->u.pair2.Class1Record)
+ return -1;
}
else
OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
-
+
case 3:
- OTF_ERROR (OTF_ERROR_TABLE, " (not yet supported)");
+ if (subtable->Format == 1)
+ {
+ if (read_coverage (otf, stream, offset, &subtable->Coverage) < 0)
+ return -1;
+ subtable->u.cursive1.EntryExitCount
+ = read_entry_exit_list (otf, stream, offset,
+ &subtable->u.cursive1.EntryExitRecord);
+ if (! subtable->u.cursive1.EntryExitCount)
+ return -1;
+ }
+ else
+ OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
case 4:
break;
case 5:
- OTF_ERROR (OTF_ERROR_TABLE, " (not yet supported)");
+ if (subtable->Format == 1)
+ {
+ read_coverage (otf, stream, offset, &subtable->Coverage);
+ read_coverage (otf, stream, offset,
+ &subtable->u.mark_lig1.LigatureCoverage);
+ READ_UINT16 (stream, subtable->u.mark_lig1.ClassCount);
+ read_mark_array (otf, stream, offset,
+ &subtable->u.mark_lig1.MarkArray);
+ read_ligature_array (otf, stream, offset,
+ subtable->u.mark_lig1.ClassCount,
+ &subtable->u.mark_lig1.LigatureArray);
+ }
break;
case 6:
read_coverage (otf, stream, offset, &subtable->Coverage);
read_coverage (otf, stream, offset,
&subtable->u.mark_mark1.Mark2Coverage);
- READ_UINT16 (stream, subtable->u.mark_base1.ClassCount);
+ READ_UINT16 (stream, subtable->u.mark_mark1.ClassCount);
read_mark_array (otf, stream, offset,
&subtable->u.mark_mark1.Mark1Array);
read_anchor_array (otf, stream, offset,
break;
case 9:
- OTF_ERROR (OTF_ERROR_TABLE, " (not yet supported)");
+ if (subtable->Format == 1)
+ {
+ unsigned ex_type;
+ long ex_offset;
+ OTF_LookupSubTableGPOS *ex_subtable;
+
+ READ_USHORT (stream, ex_type);
+ READ_ULONG (stream, ex_offset);
+ OTF_CALLOC (ex_subtable, 1, " (SubTable)");
+ if (read_lookup_subtable_gpos (otf, stream, offset + ex_offset,
+ ex_type, ex_subtable) < 0)
+ return errret;
+ subtable->u.extension1.ExtensionLookupType = ex_type;
+ subtable->u.extension1.ExtensionOffset = ex_offset;
+ subtable->u.extension1.ExtensionSubtable = ex_subtable;
+ }
+ else
+ OTF_ERROR (OTF_ERROR_TABLE, " (Invalid SubFormat)");
break;
default:
}
static void *
-read_gpos_table (OTF *otf, OTF_Stream *stream)
+read_gpos_table (OTF *otf, OTF_TableInfo *table, enum OTF_ReaderFlag flag)
{
- return read_gsub_gpos_table (otf, stream, 0);
+ return read_gsub_gpos_table (otf, table, 0, flag);
}
\f
\f
/*** (1-11) Structure for OTF */
-int
+static int
read_offset_table (OTF *otf, OTF_Stream *stream, OTF_OffsetTable *table)
-{
+{
int errret = -1;
READ_FIXED (stream, table->sfnt_version);
table->tag = tag;
table->name[0] = tag >> 24;
table->name[1] = (tag >> 16) & 0xFF;
- table->name[0] = (tag >> 8) & 0xFF;
- table->name[0] = tag >> 8;
- table->name[0] = '\0';
+ table->name[2] = (tag >> 8) & 0xFF;
+ table->name[3] = tag & 0xFF;
+ table->name[4] = '\0';
READ_ULONG (stream, table->checkSum);
READ_ULONG (stream, table->offset);
READ_ULONG (stream, table->length);
}
static int
-read_header_part (OTF *otf, FILE *fp)
+read_header_part (OTF *otf, FILE *fp, FT_Face face)
{
char *errfmt = "otf header%s";
int errret = -1;
- OTF_Tag head_tag, name_tag, cmap_tag, gdef_tag, gsub_tag, gpos_tag;
- OTF_Stream *stream;
int i;
OTF_InternalData *internal_data = (OTF_InternalData *) otf->internal_data;
internal_data->table_info[OTF_TABLE_TYPE_GPOS].address = (void *) &otf->gpos;
internal_data->table_info[OTF_TABLE_TYPE_GPOS].reader = read_gpos_table;
- head_tag = OTF_tag ("head");
- name_tag = OTF_tag ("name");
- cmap_tag = OTF_tag ("cmap");
- gdef_tag = OTF_tag ("GDEF");
- gsub_tag = OTF_tag ("GSUB");
- gpos_tag = OTF_tag ("GPOS");
-
- stream = make_stream ();
- if (! stream)
- return -1;
-
- internal_data->header_stream = stream;
-
- /* Size of Offset Table is 12 bytes. */
- if (setup_stream (stream, fp, 0, 12, "Offset Table") < 0)
- return -1;
- if (read_offset_table (otf, stream, &otf->offset_table) < 0)
- return -1;
-
- /* Size of each Table Directory is 16 bytes. */
- if (setup_stream (stream, fp, 12, 16 * otf->offset_table.numTables,
- "Table Directory") < 0)
- return -1;
-
- OTF_CALLOC (otf->table_dirs, otf->offset_table.numTables, " (OffsetTable)");
- for (i = 0; i < otf->offset_table.numTables; i++)
+ if (fp)
{
- OTF_Tag tag = read_table_directory (stream, otf->table_dirs + i);
- OTF_TableInfo *table_info = NULL;
+ OTF_Tag head_tag = OTF_tag ("head");
+ OTF_Tag name_tag = OTF_tag ("name");
+ OTF_Tag cmap_tag = OTF_tag ("cmap");
+ OTF_Tag gdef_tag = OTF_tag ("GDEF");
+ OTF_Tag gsub_tag = OTF_tag ("GSUB");
+ OTF_Tag gpos_tag = OTF_tag ("GPOS");
+ OTF_Stream *stream = make_stream ("Offset Table");
+ unsigned char ttctag[4];
- if (! tag)
+ if (! stream)
+ return -1;
+ internal_data->header_stream = stream;
+
+ /* Size of Offset Table is 12 bytes. Size of TTC header
+ (including only the an offset of the first font) is 16. */
+ if (setup_stream (stream, fp, 0, 16) < 0)
return -1;
- if (tag == head_tag)
- table_info = internal_data->table_info + OTF_TABLE_TYPE_HEAD;
- else if (tag == name_tag)
- table_info = internal_data->table_info + OTF_TABLE_TYPE_NAME;
- else if (tag == cmap_tag)
- table_info = internal_data->table_info + OTF_TABLE_TYPE_CMAP;
- else if (tag == gdef_tag)
- table_info = internal_data->table_info + OTF_TABLE_TYPE_GDEF;
- else if (tag == gsub_tag)
- table_info = internal_data->table_info + OTF_TABLE_TYPE_GSUB;
- else if (tag == gpos_tag)
- table_info = internal_data->table_info + OTF_TABLE_TYPE_GPOS;
-
- if (table_info)
+ READ_BYTES (stream, ttctag, 4);
+ if (memcmp (ttctag, "ttcf", 4) == 0)
{
- table_info->stream = make_stream ();
- if (setup_stream (table_info->stream, fp,
- otf->table_dirs[i].offset,
- otf->table_dirs[i].length,
- otf->table_dirs[i].name) < 0)
+ /* This is a TrueType Collection file. We extract the first font. */
+ unsigned version, numfonts, offset;
+ READ_ULONG (stream, version);
+ READ_ULONG (stream, numfonts);
+ READ_ULONG (stream, offset); /* Offset of the first font. */
+ if (setup_stream (stream, fp, offset, 12) < 0)
return -1;
}
+ else
+ SEEK_STREAM (stream, 0L);
+ if (read_offset_table (otf, stream, &otf->offset_table) < 0)
+ return -1;
+ /* Size of each Table Directory is 16 bytes. */
+ if (setup_stream (stream, fp, stream->pos,
+ 16 * otf->offset_table.numTables) < 0)
+ return -1;
+
+ OTF_CALLOC (otf->table_dirs, otf->offset_table.numTables,
+ " (OffsetTable)");
+ for (i = 0; i < otf->offset_table.numTables; i++)
+ {
+ OTF_Tag tag = read_table_directory (stream, otf->table_dirs + i);
+ OTF_TableInfo *table_info = NULL;
+
+ if (! tag)
+ return -1;
+ if (tag == head_tag)
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_HEAD;
+ else if (tag == name_tag)
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_NAME;
+ else if (tag == cmap_tag)
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_CMAP;
+ else if (tag == gdef_tag)
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_GDEF;
+ else if (tag == gsub_tag)
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_GSUB;
+ else if (tag == gpos_tag)
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_GPOS;
+
+ if (table_info)
+ {
+ table_info->stream = make_stream (otf->table_dirs[i].name);
+ if (setup_stream (table_info->stream, fp,
+ otf->table_dirs[i].offset,
+ otf->table_dirs[i].length) < 0)
+ return -1;
+ }
+ }
+
+ internal_data->header_stream = NULL;
+ free_stream (stream);
+ }
+ else
+ {
+ OTF_Stream *stream;
+
+ internal_data->header_stream = NULL;
+ if ((stream = make_stream_from_ft_face (face, "head")))
+ internal_data->table_info[OTF_TABLE_TYPE_HEAD].stream = stream;
+ if ((stream = make_stream_from_ft_face (face, "name")))
+ internal_data->table_info[OTF_TABLE_TYPE_NAME].stream = stream;
+ if ((stream = make_stream_from_ft_face (face, "cmap")))
+ internal_data->table_info[OTF_TABLE_TYPE_CMAP].stream = stream;
+ if ((stream = make_stream_from_ft_face (face, "GDEF")))
+ internal_data->table_info[OTF_TABLE_TYPE_GDEF].stream = stream;
+ if ((stream = make_stream_from_ft_face (face, "GSUB")))
+ internal_data->table_info[OTF_TABLE_TYPE_GSUB].stream = stream;
+ if ((stream = make_stream_from_ft_face (face, "GPOS")))
+ internal_data->table_info[OTF_TABLE_TYPE_GPOS].stream = stream;
}
- internal_data->header_stream = NULL;
- free_stream (stream);
+ if (! internal_data->table_info[OTF_TABLE_TYPE_GDEF].stream)
+ /* We can simulate the GDEF table. */
+ internal_data->table_info[OTF_TABLE_TYPE_GDEF].stream
+ = make_stream ("GDEF");
return 0;
}
+static OTF_TableInfo *
+get_table_info (OTF *otf, const char *name)
+{
+ char *errfmt = "OTF Table Read%s";
+ OTF_TableInfo *errret = NULL;
+ OTF_InternalData *internal_data = otf->internal_data;
+ OTF_TableInfo *table_info;
+ OTF_Tag tag = OTF_tag (name);
+
+ if (! tag)
+ OTF_ERROR (OTF_ERROR_TABLE, " (invalid table name)");
+
+ if (tag == OTF_tag ("head"))
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_HEAD;
+ else if (tag == OTF_tag ("name"))
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_NAME;
+ else if (tag == OTF_tag ("cmap"))
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_CMAP;
+ else if (tag == OTF_tag ("GDEF"))
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_GDEF;
+ else if (tag == OTF_tag ("GSUB"))
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_GSUB;
+ else if (tag == OTF_tag ("GPOS"))
+ table_info = internal_data->table_info + OTF_TABLE_TYPE_GPOS;
+ else
+ OTF_ERROR (OTF_ERROR_TABLE, " (unsupported table name)");
+
+ if (*table_info->address)
+ /* Already read. */
+ return table_info;
+ if (! table_info->stream)
+ OTF_ERROR (OTF_ERROR_TABLE, " (table not found)");
+ if (! table_info->reader)
+ OTF_ERROR (OTF_ERROR_TABLE, " (invalid contents)");
+ return table_info;
+}
+
+
\f
-/*** (2) APIs for reading OTF */
+/*** (2) API for reading OTF */
/*** (2-1) OTF_open() */
freeing memory previously allocated. */
OTF *
-OTF_open (char *otf_name)
+OTF_open (const char *otf_name)
{
FILE *fp;
char *errfmt = "opening otf (%s)";
void *errret = NULL;
OTF *otf;
OTF_InternalData *internal_data;
+ int len = strlen (otf_name);
+ const char *ext = otf_name + (len - 4);
+
+ if (debug_flag < 0)
+ set_debug_flag ();
+ if (len < 4
+ || ext[0] != '.'
+ || (strncasecmp (ext + 1, "otf", 3)
+ && strncasecmp (ext + 1, "ttf", 3)
+ && strncasecmp (ext + 1, "ttc", 3)))
+ OTF_ERROR (OTF_ERROR_FILE, otf_name);
fp = fopen (otf_name, "r");
if (! fp)
OTF_ERROR (OTF_ERROR_FILE, otf_name);
otf->internal_data->memory_record except for what allocated by
the functions allocate_memory_record and make_stream. */
- if (read_header_part (otf, fp) < 0)
+ if (read_header_part (otf, fp, NULL) < 0)
{
OTF_close (otf);
fclose (fp);
return otf;
}
+OTF *
+OTF_open_ft_face (FT_Face face)
+{
+ char *errfmt = "opening otf from Freetype (%s)";
+ void *errret = NULL;
+ OTF *otf;
+ OTF_InternalData *internal_data;
+
+ if (debug_flag < 0)
+ set_debug_flag ();
+
+ if (! FT_IS_SFNT (face))
+ OTF_ERROR (OTF_ERROR_FILE, (char *) face->family_name);
+ otf = calloc (1, sizeof (OTF));
+ if (! otf)
+ OTF_ERROR (OTF_ERROR_MEMORY, "body allocation");
+ otf->filename = NULL;
+
+ internal_data = calloc (1, sizeof (OTF_InternalData));
+ if (! internal_data)
+ OTF_ERROR (OTF_ERROR_MEMORY, " (InternalData");
+ otf->internal_data = internal_data;
+ if (! allocate_memory_record (otf))
+ OTF_ERROR (OTF_ERROR_MEMORY, " (InternalData)");
+
+ if (read_header_part (otf, NULL, face) < 0)
+ {
+ OTF_close (otf);
+ return NULL;
+ }
+
+ return otf;
+}
+
/*** (2-2) OTF_close() */
void
if (internal_data)
{
OTF_MemoryRecord *memrec = internal_data->memory_record;
+ OTF_ApplicationData *app_data = internal_data->app_data;
if (internal_data->header_stream)
free_stream (internal_data->header_stream);
if (internal_data->table_info[i].stream)
free_stream (internal_data->table_info[i].stream);
+ for (; app_data; app_data = app_data->next)
+ if (app_data->data && app_data->freer)
+ app_data->freer (app_data->data);
+
while (memrec)
{
OTF_MemoryRecord *next = memrec->next;
free (memrec);
memrec = next;
}
+
free (internal_data);
}
+ if (otf->filename)
+ free (otf->filename);
free (otf);
}
/*** (2-3) OTF_get_table() */
int
-OTF_get_table (OTF *otf, char *name)
+OTF_get_table (OTF *otf, const char *name)
{
- char *errfmt = "OTF Table Read%s";
- int errret = -1;
- OTF_InternalData *internal_data = otf->internal_data;
- OTF_TableInfo *table_info;
- OTF_Tag tag = OTF_tag (name);
+ OTF_TableInfo *table_info = get_table_info (otf, name);
+ void *address;
- if (! tag)
- OTF_ERROR (OTF_ERROR_TABLE, " (invalid table name)");
-
- if (tag == OTF_tag ("head"))
- table_info = internal_data->table_info + OTF_TABLE_TYPE_HEAD;
- else if (tag == OTF_tag ("name"))
- table_info = internal_data->table_info + OTF_TABLE_TYPE_NAME;
- else if (tag == OTF_tag ("cmap"))
- table_info = internal_data->table_info + OTF_TABLE_TYPE_CMAP;
- else if (tag == OTF_tag ("GDEF"))
- table_info = internal_data->table_info + OTF_TABLE_TYPE_GDEF;
- else if (tag == OTF_tag ("GSUB"))
- table_info = internal_data->table_info + OTF_TABLE_TYPE_GSUB;
- else if (tag == OTF_tag ("GPOS"))
- table_info = internal_data->table_info + OTF_TABLE_TYPE_GPOS;
- else
- OTF_ERROR (OTF_ERROR_TABLE, " (not yet supported table name)");
-
- if (*table_info->address)
- /* Already read. */
- return 0;
+ if (! table_info)
+ return -1;
if (! table_info->stream)
- OTF_ERROR (OTF_ERROR_TABLE, " (table not found)");
- if (! table_info->reader)
- OTF_ERROR (OTF_ERROR_TABLE, " (invalid contents)");
+ /* Already fully loaded. */
+ return 0;
- *table_info->address = (*table_info->reader) (otf, table_info->stream);
+ address = (*table_info->reader) (otf, table_info, OTF_READ_FULL);
free_stream (table_info->stream);
table_info->stream = NULL;
- if (! *table_info->address)
+ if (! address)
{
table_info->reader = NULL;
- return errret;
+ return -1;
}
+ return 0;
+}
+
+/*** (2-4) OTF_check_table() */
+int
+OTF_check_table (OTF *otf, const char *name)
+{
+ return (get_table_info (otf, name) ? 0 : -1);
+}
+
+/*** (2-5) OTF_get_scripts() */
+
+int
+OTF_get_scripts (OTF *otf, int gsubp)
+{
+ OTF_TableInfo *table_info
+ = (otf->internal_data->table_info
+ + (gsubp ? OTF_TABLE_TYPE_GSUB : OTF_TABLE_TYPE_GPOS));
+ void *address;
+
+ if (! table_info->reader)
+ return -1;
+ if (! table_info->stream)
+ /* Already fully loaded. */
+ return 0;
+
+ address = (*table_info->reader) (otf, table_info, OTF_READ_SCRIPTS);
+ if (! address)
+ {
+ table_info->reader = NULL;
+ return -1;
+ }
return 0;
}
+/*** (2-6) OTF_get_features() */
+
+int
+OTF_get_features (OTF *otf, int gsubp)
+{
+ OTF_TableInfo *table_info
+ = (otf->internal_data->table_info
+ + (gsubp ? OTF_TABLE_TYPE_GSUB : OTF_TABLE_TYPE_GPOS));
+ void *address;
+
+ if (! table_info->reader)
+ return -1;
+ if (! table_info->stream)
+ {
+ if (*table_info->address)
+ /* Already fully loaded. */
+ return 0;
+ return -1;
+ }
+
+ address = (*table_info->reader) (otf, table_info, OTF_READ_FEATURES);
+ if (! address)
+ {
+ table_info->reader = NULL;
+ return -1;
+ }
+ return 0;
+}
+
+/*** (2-7) OTF_check_features */
+
+int
+OTF_check_features (OTF *otf, int gsubp,
+ OTF_Tag script, OTF_Tag language, const OTF_Tag *features,
+ int n_features)
+{
+ OTF_ScriptList *script_list;
+ OTF_Script *Script = NULL;
+ OTF_LangSys *LangSys = NULL;
+ OTF_FeatureList *feature_list;
+ int i, j;
+
+ if (OTF_get_features (otf, gsubp) < 0)
+ {
+ if (gsubp ? ! otf->gsub : ! otf->gpos)
+ return 0;
+ for (i = 0; i < n_features; i++)
+ {
+ OTF_Tag feature = features[i];
+
+ if (feature == 0)
+ continue;
+ if ((((unsigned) feature) & 0x80000000) == 0)
+ return -1;
+ }
+ }
+ if (gsubp)
+ {
+ script_list = &otf->gsub->ScriptList;
+ feature_list = &otf->gsub->FeatureList;
+ }
+ else
+ {
+ script_list = &otf->gpos->ScriptList;
+ feature_list = &otf->gpos->FeatureList;
+ }
+ for (i = 0; i < script_list->ScriptCount && ! Script; i++)
+ if (script_list->Script[i].ScriptTag == script)
+ Script = script_list->Script + i;
+ if (! Script)
+ return 0;
+ if (language)
+ {
+ for (i = 0; i < Script->LangSysCount && ! LangSys; i++)
+ if (Script->LangSysRecord[i].LangSysTag == language)
+ LangSys = Script->LangSys + i;
+ if (! LangSys)
+ return 0;
+ }
+ else
+ LangSys = &Script->DefaultLangSys;
+ for (j = 0; j < n_features; j++)
+ {
+ OTF_Tag feature = features[j];
+ int negate = 0;
+
+ if (feature == 0)
+ continue;
+ if (((unsigned) feature) & 0x80000000)
+ {
+ feature = (OTF_Tag) (((unsigned) feature) & 0x7FFFFFFF);
+ negate = 1;
+ }
+ for (i = 0; i < LangSys->FeatureCount; i++)
+ if (feature_list->Feature[LangSys->FeatureIndex[i]].FeatureTag
+ == feature)
+ {
+ if (negate)
+ return 0;
+ break;
+ }
+ if (i == LangSys->FeatureCount)
+ return 0;
+ }
+ return 1;
+}
+
\f
-/*** (5) APIs miscellaneous ***/
+/*** (5) API miscellaneous ***/
OTF_Tag
-OTF_tag (char *name)
+OTF_tag (const char *name)
{
- unsigned char *p = (unsigned char *) name;
+ const unsigned char *p = (unsigned char *) name;
if (! name)
return (OTF_Tag) 0;
- return (OTF_Tag) ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
+ return (OTF_Tag) ((p[0] << 24)
+ | (! p[1] ? 0
+ : ((p[1] << 16)
+ | (! p[2] ? 0
+ : (p[2] << 8) | p[3]))));
}
void
name[3] = (char) (tag & 0xFF);
name[4] = '\0';
}
+
+int
+OTF_put_data (OTF *otf, char *id, void *data, void (*freer) (void *data))
+{
+ char *errfmt = "appdata %s";
+ int errret = -1;
+ OTF_InternalData *internal_data = (OTF_InternalData *) otf->internal_data;
+ OTF_ApplicationData *app_data = internal_data->app_data;
+ int len = strlen (id) + 1;
+
+ for (; app_data; app_data = app_data->next)
+ if (memcmp (app_data->id, id, len) == 0)
+ {
+ if (app_data->data && app_data->freer)
+ app_data->freer (app_data->data);
+ break;
+ }
+ if (! app_data)
+ {
+ OTF_MALLOC (app_data, sizeof (OTF_ApplicationData), id);
+ app_data->next = internal_data->app_data;
+ internal_data->app_data = app_data;
+ OTF_MALLOC (app_data->id, len, id);
+ memcpy (app_data->id, id, len);
+ }
+ app_data->data = data;
+ app_data->freer = freer;
+ return 0;
+}
+
+void *
+OTF_get_data (OTF *otf, char *id)
+{
+ OTF_InternalData *internal_data = (OTF_InternalData *) otf->internal_data;
+ OTF_ApplicationData *app_data = internal_data->app_data;
+
+ for (; app_data; app_data = app_data->next)
+ if (strcmp (app_data->id, id) == 0)
+ return app_data->data;
+ return NULL;
+}
projects / m17n / libotf.git / blobdiff