ttf2eot 0.1

data/Rakefile

@@ -0,0 +1,4 @@
+require "rake"
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new('ttf2eot_ext')

data/ext/ttf2eot_ext/OpenTypeUtilities.cpp

@@ -0,0 +1,334 @@
+/* Modified for use with ttf2eot, originally from WebKit. */
+
+/*
+ * Copyright (C) 2008 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#include <string.h>
+#include <vector>
+
+#ifndef _MSC_VER
+# include <stdint.h>
+#else
+typedef unsigned char uint8_t;
+#endif
+
+#include "OpenTypeUtilities.h"
+
+
+using std::vector;
+
+typedef unsigned Fixed;
+
+#define DEFAULT_CHARSET 1
+
+struct BigEndianUShort { 
+    operator unsigned short() const { return (v & 0x00ff) << 8 | v >> 8; }
+    BigEndianUShort(unsigned short u) : v((u & 0x00ff) << 8 | u >> 8) { }
+    unsigned short v;
+};
+
+struct BigEndianULong { 
+    operator unsigned() const { return (v & 0xff) << 24 | (v & 0xff00) << 8 | (v & 0xff0000) >> 8 | v >> 24; }
+    BigEndianULong(unsigned u) : v((u & 0xff) << 24 | (u & 0xff00) << 8 | (u & 0xff0000) >> 8 | u >> 24) { }
+    unsigned v;
+};
+
+#pragma pack(1)
+
+struct EOTPrefix {
+    unsigned eotSize;
+    unsigned fontDataSize;
+    unsigned version;
+    unsigned flags;
+    uint8_t fontPANOSE[10];
+    uint8_t charset;
+    uint8_t italic;
+    unsigned weight;
+    unsigned short fsType;
+    unsigned short magicNumber;
+    unsigned unicodeRange[4];
+    unsigned codePageRange[2];
+    unsigned checkSumAdjustment;
+    unsigned reserved[4];
+    unsigned short padding1;
+};
+
+struct TableDirectoryEntry {
+    BigEndianULong tag;
+    BigEndianULong checkSum;
+    BigEndianULong offset;
+    BigEndianULong length;
+};
+
+struct sfntHeader {
+    Fixed version;
+    BigEndianUShort numTables;
+    BigEndianUShort searchRange;
+    BigEndianUShort entrySelector;
+    BigEndianUShort rangeShift;
+    TableDirectoryEntry tables[1];
+};
+
+struct OS2Table {
+    BigEndianUShort version;
+    BigEndianUShort avgCharWidth;
+    BigEndianUShort weightClass;
+    BigEndianUShort widthClass;
+    BigEndianUShort fsType;
+    BigEndianUShort subscriptXSize;
+    BigEndianUShort subscriptYSize;
+    BigEndianUShort subscriptXOffset;
+    BigEndianUShort subscriptYOffset;
+    BigEndianUShort superscriptXSize;
+    BigEndianUShort superscriptYSize;
+    BigEndianUShort superscriptXOffset;
+    BigEndianUShort superscriptYOffset;
+    BigEndianUShort strikeoutSize;
+    BigEndianUShort strikeoutPosition;
+    BigEndianUShort familyClass;
+    uint8_t panose[10];
+    BigEndianULong unicodeRange[4];
+    uint8_t vendID[4];
+    BigEndianUShort fsSelection;
+    BigEndianUShort firstCharIndex;
+    BigEndianUShort lastCharIndex;
+    BigEndianUShort typoAscender;
+    BigEndianUShort typoDescender;
+    BigEndianUShort typoLineGap;
+    BigEndianUShort winAscent;
+    BigEndianUShort winDescent;
+    BigEndianULong codePageRange[2];
+    BigEndianUShort xHeight;
+    BigEndianUShort capHeight;
+    BigEndianUShort defaultChar;
+    BigEndianUShort breakChar;
+    BigEndianUShort maxContext;
+};
+
+struct headTable {
+    Fixed version;
+    Fixed fontRevision;
+    BigEndianULong checkSumAdjustment;
+    BigEndianULong magicNumber;
+    BigEndianUShort flags;
+    BigEndianUShort unitsPerEm;
+    long long created;
+    long long modified;
+    BigEndianUShort xMin;
+    BigEndianUShort xMax;
+    BigEndianUShort yMin;
+    BigEndianUShort yMax;
+    BigEndianUShort macStyle;
+    BigEndianUShort lowestRectPPEM;
+    BigEndianUShort fontDirectionHint;
+    BigEndianUShort indexToLocFormat;
+    BigEndianUShort glyphDataFormat;
+};
+
+struct nameRecord {
+    BigEndianUShort platformID;
+    BigEndianUShort encodingID;
+    BigEndianUShort languageID;
+    BigEndianUShort nameID;
+    BigEndianUShort length;
+    BigEndianUShort offset;
+};
+
+struct nameTable {
+    BigEndianUShort format;
+    BigEndianUShort count;
+    BigEndianUShort stringOffset;
+    nameRecord nameRecords[1];
+};
+
+#pragma pack()
+
+static void appendBigEndianStringToEOTHeader(vector<uint8_t>&eotHeader, const BigEndianUShort* string, unsigned short length)
+{
+    size_t size = eotHeader.size();
+    eotHeader.resize(size + length + 2 * sizeof(unsigned short));
+    unsigned short* dst = reinterpret_cast<unsigned short*>(&eotHeader[0] + size);
+    unsigned i = 0;
+    dst[i++] = length;
+    unsigned numCharacters = length / 2;
+    for (unsigned j = 0; j < numCharacters; j++)
+        dst[i++] = string[j];
+    dst[i] = 0;
+}
+
+bool getEOTHeader(unsigned char* fontData, size_t fontSize, vector<uint8_t>& eotHeader, size_t& overlayDst, size_t& overlaySrc, size_t& overlayLength)
+{
+    overlayDst = 0;
+    overlaySrc = 0;
+    overlayLength = 0;
+
+    size_t dataLength = fontSize;
+    const char* data = (const char *) fontData;
+
+    eotHeader.resize(sizeof(EOTPrefix));
+    EOTPrefix* prefix = reinterpret_cast<EOTPrefix*>(&eotHeader[0]);
+
+    prefix->fontDataSize = dataLength;
+    prefix->version = 0x00020001;
+    prefix->flags = 0;
+
+    if (dataLength < offsetof(sfntHeader, tables))
+        return false;
+
+    const sfntHeader* sfnt = reinterpret_cast<const sfntHeader*>(data);
+
+    if (dataLength < offsetof(sfntHeader, tables) + sfnt->numTables * sizeof(TableDirectoryEntry))
+        return false;
+
+    bool haveOS2 = false;
+    bool haveHead = false;
+    bool haveName = false;
+
+    const BigEndianUShort* familyName = 0;
+    unsigned short familyNameLength = 0;
+    const BigEndianUShort* subfamilyName = 0;
+    unsigned short subfamilyNameLength = 0;
+    const BigEndianUShort* fullName = 0;
+    unsigned short fullNameLength = 0;
+    const BigEndianUShort* versionString = 0;
+    unsigned short versionStringLength = 0;
+
+    for (unsigned i = 0; i < sfnt->numTables; i++) {
+        unsigned tableOffset = sfnt->tables[i].offset;
+        unsigned tableLength = sfnt->tables[i].length;
+
+        if (dataLength < tableOffset || dataLength < tableLength || dataLength < tableOffset + tableLength)
+            return false;
+
+        unsigned tableTag = sfnt->tables[i].tag;
+        switch (tableTag) {
+            case 'OS/2':
+                {
+                    if (dataLength < tableOffset + sizeof(OS2Table))
+                        return false;
+
+                    haveOS2 = true;
+                    const OS2Table* OS2 = reinterpret_cast<const OS2Table*>(data + tableOffset);
+                    for (unsigned j = 0; j < 10; j++)
+                        prefix->fontPANOSE[j] = OS2->panose[j];
+                    prefix->italic = OS2->fsSelection & 0x01;
+                    prefix->weight = OS2->weightClass;
+                    // FIXME: Should use OS2->fsType, but some TrueType fonts set it to an over-restrictive value.
+                    // Since ATS does not enforce this on Mac OS X, we do not enforce it either.
+                    prefix->fsType = 0;            
+                    for (unsigned j = 0; j < 4; j++)
+                        prefix->unicodeRange[j] = OS2->unicodeRange[j];
+                    for (unsigned j = 0; j < 2; j++)
+                        prefix->codePageRange[j] = OS2->codePageRange[j];
+                    break;
+                }
+            case 'head':
+                {
+                    if (dataLength < tableOffset + sizeof(headTable))
+                        return false;
+
+                    haveHead = true;
+                    const headTable* head = reinterpret_cast<const headTable*>(data + tableOffset);
+                    prefix->checkSumAdjustment = head->checkSumAdjustment;
+                    break;
+                }
+            case 'name':
+                {
+                    if (dataLength < tableOffset + offsetof(nameTable, nameRecords))
+                        return false;
+
+                    haveName = true;
+                    const nameTable* name = reinterpret_cast<const nameTable*>(data + tableOffset);
+                    for (int j = 0; j < name->count; j++) {
+                        if (dataLength < tableOffset + offsetof(nameTable, nameRecords) + (j + 1) * sizeof(nameRecord))
+                            return false;
+                        if (name->nameRecords[j].platformID == 3 && name->nameRecords[j].encodingID == 1 && name->nameRecords[j].languageID == 0x0409) {
+                            if (dataLength < tableOffset + name->stringOffset + name->nameRecords[j].offset + name->nameRecords[j].length)
+                                return false;
+
+                            unsigned short nameLength = name->nameRecords[j].length;
+                            const BigEndianUShort* nameString = reinterpret_cast<const BigEndianUShort*>(data + tableOffset + name->stringOffset + name->nameRecords[j].offset);
+                            
+                            switch (name->nameRecords[j].nameID) {
+                                case 1:
+                                    familyNameLength = nameLength;
+                                    familyName = nameString;
+                                    break;
+                                case 2:
+                                    subfamilyNameLength = nameLength;
+                                    subfamilyName = nameString;
+                                    break;
+                                case 4:
+                                    fullNameLength = nameLength;
+                                    fullName = nameString;
+                                    break;
+                                case 5:
+                                    versionStringLength = nameLength;
+                                    versionString = nameString;
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    break;
+                }
+            default:
+                break;
+        }
+        if (haveOS2 && haveHead && haveName)
+            break;
+    }
+
+    prefix->charset = DEFAULT_CHARSET;
+    prefix->magicNumber = 0x504c;
+    prefix->reserved[0] = 0;
+    prefix->reserved[1] = 0;
+    prefix->reserved[2] = 0;
+    prefix->reserved[3] = 0;
+    prefix->padding1 = 0;
+
+    appendBigEndianStringToEOTHeader(eotHeader, familyName, familyNameLength);
+    appendBigEndianStringToEOTHeader(eotHeader, subfamilyName, subfamilyNameLength);
+    appendBigEndianStringToEOTHeader(eotHeader, versionString, versionStringLength);
+
+    // If possible, ensure that the family name is a prefix of the full name.
+    if (fullNameLength >= familyNameLength && memcmp(familyName, fullName, familyNameLength)) {
+        overlaySrc = reinterpret_cast<const char*>(fullName) - data;
+        overlayDst = reinterpret_cast<const char*>(familyName) - data;
+        overlayLength = familyNameLength;
+    }
+
+    appendBigEndianStringToEOTHeader(eotHeader, fullName, fullNameLength);
+
+    unsigned short padding = 0;
+    eotHeader.push_back(padding);
+    eotHeader.push_back(padding);
+
+    prefix = reinterpret_cast<EOTPrefix*>(&eotHeader[0]);
+    prefix->eotSize = eotHeader.size() + fontSize;
+
+    return true;
+}

data/ext/ttf2eot_ext/OpenTypeUtilities.h

@@ -0,0 +1,36 @@
+/* Modified for use with ttf2eot, originally from WebKit. */
+
+/*
+ * Copyright (C) 2008 Apple Inc.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ */
+
+#ifndef OpenTypeUtilities_h
+#define OpenTypeUtilities_h
+
+using std::vector;
+
+bool getEOTHeader(unsigned char * fontData, size_t fontSize, vector<uint8_t>& eotHeader, size_t& overlayDst, size_t& overlaySrc, size_t& overlayLength);
+
+
+#endif // OpenTypeUtilities_h

data/ext/ttf2eot_ext/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile 'ttf2eot_ext'

data/ext/ttf2eot_ext/ttf2eot.cpp

@@ -0,0 +1,54 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+#include <ruby.h>
+
+#include <vector>
+
+#ifndef _MSC_VER
+# include <stdint.h>
+#else
+typedef unsigned char uint8_t;
+#endif
+
+#include "OpenTypeUtilities.h"
+
+VALUE eTTFConversionError;
+
+static VALUE mTTF2EOT_eot_header(VALUE self, VALUE input) {
+  vector<uint8_t> eotHeader(512);
+  bool success;
+  size_t overlayDst = 0;
+  size_t overlaySrc = 0;
+  size_t overlayLength = 0;
+
+  if ( TYPE(input) != T_STRING )
+    rb_raise(rb_eTypeError, "TTF2EOT.eot_header expects a string as input");
+
+  success = getEOTHeader(
+    (unsigned char *) RSTRING_PTR(input),
+    RSTRING_LEN(input),
+    eotHeader,
+    overlayDst,
+    overlaySrc,
+    overlayLength
+  );
+
+  if ( success ) {
+    return rb_str_new((char *) &eotHeader[0], eotHeader.size());
+  } else {
+    rb_raise(
+      eTTFConversionError,
+      "could not get EOT header - ensure input contains valid TTF font data"
+    );
+  }
+}
+
+extern "C" void Init_ttf2eot_ext() {
+  VALUE mTTF2EOT = rb_const_get(rb_cObject, rb_intern("TTF2EOT"));
+  eTTFConversionError = rb_define_class_under(mTTF2EOT, "ConversionError", rb_eStandardError);
+
+  rb_define_module_function(mTTF2EOT, "eot_header", (VALUE(*)(...))mTTF2EOT_eot_header, 1);
+}

data/lib/ttf2eot.rb

@@ -0,0 +1,47 @@
+module TTF2EOT
+  # Public: Converts a TTF font file to an EOT font.
+  #
+  # input  - the input TTF font as a String (representing a path) or IO object
+  #          (responding to #read).
+  # output - the output destination as a String (representing a path) or IO
+  #          object where the EOT font will be written.
+  #
+  # Examples:
+  #
+  #   TTF2EOT.convert("input.ttf", "output.eot")
+  #   # => #<File:output.eot>
+  #
+  #   input = StringIO.new(File.read("input.ttf"))
+  #   output = StringIO.new
+  #   TTF2EOT.convert(input, output)
+  #   # => #<StringIO:0x007f815a83a210>
+  #
+  # Returns the output IO object.
+  # Raises TTF2EOT::ConversionError if the input data is invalid.
+  def convert(input, output)
+    input = File.open(input, "rb") unless input.respond_to?(:read)
+    output = File.open(output, "wb") unless output.respond_to?(:write)
+
+    source = input.read
+    header = eot_header(source)
+
+    output.write header
+    output.write source
+    output.flush
+
+    output
+  end
+  module_function :convert
+
+  # Internal: Get an EOT header for a TTF font.
+  #
+  # font_data - a String containing valid TTF font data.
+  #
+  # Returns a String with the EOT header for the input data.
+  # Raises TTF2EOT::ConversionError if the input data is invalid.
+  def eot_header(font_data)
+    raise NotImlementedError, "this method is defined by the ttf2eot c extension"
+  end
+end
+
+require "ttf2eot_ext"

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: ttf2eot
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Bernerd Schaefer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: &70362718527040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70362718527040
+description: Convert TTF fonts to EOT fonts
+email: bj.schaefer@gmail.com
+executables: []
+extensions:
+- ext/ttf2eot_ext/extconf.rb
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/ttf2eot.rb
+- ext/ttf2eot_ext/OpenTypeUtilities.cpp
+- ext/ttf2eot_ext/ttf2eot.cpp
+- ext/ttf2eot_ext/OpenTypeUtilities.h
+- ext/ttf2eot_ext/extconf.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Convert TTF fonts to EOT fonts
+test_files: []
+has_rdoc: