fontisan 0.2.11 → 0.2.13

data/lib/fontisan/type1/pfb_generator.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require_relative "upm_scaler"
+require_relative "ttf_to_type1_converter"
+require_relative "decryptor"
+require_relative "../tables/name"
+
+module Fontisan
+  module Type1
+    # PFB (Printer Font Binary) Generator
+    #
+    # [`PFBGenerator`](lib/fontisan/type1/pfb_generator.rb) generates Type 1 PFB files
+    # from TrueType fonts.
+    #
+    # PFB files are segmented binary files used by Windows for Type 1 fonts.
+    # They contain:
+    # - ASCII segment: Font dictionary
+    # - Binary segment: CharString data
+    # - ASCII segment: Trailer
+    #
+    # @example Generate PFB from TTF
+    #   font = Fontisan::FontLoader.load("font.ttf")
+    #   pfb_data = Fontisan::Type1::PFBGenerator.generate(font)
+    #   File.binwrite("font.pfb", pfb_data)
+    #
+    # @example Generate PFB with custom options
+    #   options = { upm_scale: 1000, format: :pfb }
+    #   pfb_data = Fontisan::Type1::PFBGenerator.generate(font, options)
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/5178.Type1.pdf
+    class PFBGenerator
+      # PFB segment markers
+      ASCII_SEGMENT = 0x01
+      BINARY_SEGMENT = 0x02
+      END_SEGMENT = 0x03
+
+      # Header format string
+      PFB_HEADER = "%%!PS-AdobeFont-1.0: %s 1.0\n"
+
+      # Generate PFB from TTF font
+      #
+      # @param font [Fontisan::Font] Source TTF font
+      # @param options [Hash] Generation options
+      # @option options [Integer, :native] :upm_scale Target UPM (default: 1000)
+      # @option options [Class] :encoding Encoding class (default: Encodings::AdobeStandard)
+      # @option options [Boolean] :convert_curves Convert quadratic to cubic (default: true)
+      # @return [String] PFB file content (binary)
+      def self.generate(font, options = {})
+        new(font, options).generate
+      end
+
+      def initialize(font, options = {})
+        @font = font
+        @options = options
+        @metrics = MetricsCalculator.new(font)
+
+        # Set up scaler
+        upm_scale = options[:upm_scale] || 1000
+        @scaler = if upm_scale == :native
+                    UPMScaler.native(font)
+                  else
+                    UPMScaler.new(font, target_upm: upm_scale)
+                  end
+
+        # Set up encoding
+        @encoding = options[:encoding] || Encodings::AdobeStandard
+
+        # Set up converter options
+        @convert_curves = options.fetch(:convert_curves, true)
+      end
+
+      # Generate PFB file content
+      #
+      # @return [String] PFB binary content
+      def generate
+        # Build PFB segments
+        ascii_segment1 = build_ascii_segment_1
+        binary_segment = build_binary_segment
+        ascii_segment2 = build_ascii_segment_2
+
+        # Combine with segment headers
+        [
+          segment_header(ASCII_SEGMENT, ascii_segment1.bytesize),
+          ascii_segment1,
+          segment_header(BINARY_SEGMENT, binary_segment.bytesize),
+          binary_segment,
+          segment_header(ASCII_SEGMENT, ascii_segment2.bytesize),
+          ascii_segment2,
+          [END_SEGMENT, 0, 0, 0, 0, 0].pack("CV"),
+        ].join
+      end
+
+      private
+
+      # Build first ASCII segment (font dictionary)
+      #
+      # @return [String] ASCII font dictionary
+      def build_ascii_segment_1
+        lines = []
+        lines << format(PFB_HEADER, @font.post_script_name)
+        lines << build_font_dict
+        lines << build_private_dict
+        lines << build_charstrings_dict
+        lines.join("\n")
+      end
+
+      # Build font dictionary
+      #
+      # @return [String] Font dictionary in PostScript
+      def build_font_dict
+        dict = []
+        dict << "10 dict begin"
+        dict << "/FontType 1 def"
+        dict << "/FontMatrix [0.001 0 0 0.001 0 0] def"
+
+        # Font info
+        name_table = @font.table(Constants::NAME_TAG)
+        if name_table
+          font_name = name_table.english_name(Tables::Name::POSTSCRIPT_NAME) || @font.post_script_name
+          dict << "/FontName /#{font_name} def"
+        end
+
+        # Bounding box
+        head = @font.table(Constants::HEAD_TAG)
+        if head
+          bbox = [
+            @scaler.scale(head.x_min || 0),
+            @scaler.scale(head.y_min || 0),
+            @scaler.scale(head.x_max || 1000),
+            @scaler.scale(head.y_max || 1000),
+          ]
+          dict << "/FontBBox {#{bbox.join(' ')}} def"
+        end
+
+        # Paint type
+        dict << "/PaintType 0 def"
+
+        # Encoding
+        if @encoding == Encodings::AdobeStandard
+          dict << "/Encoding StandardEncoding def"
+        elsif @encoding == Encodings::ISOLatin1
+          dict << "/Encoding ISOLatin1Encoding def"
+        end
+
+        dict << "currentdict end"
+        dict << "dup /FontName get exch definefont pop"
+
+        dict.join("\n")
+      end
+
+      # Build Private dictionary
+      #
+      # @return [String] Private dictionary in PostScript
+      def build_private_dict
+        dict = []
+        dict << "/Private 15 dict begin"
+
+        # Blue values (for hinting)
+        # These are typically derived from the font's alignment zones
+        dict << "/BlueValues [-20 0 500 510] def"
+        dict << "/BlueScale 0.039625 def"
+        dict << "/BlueShift 7 def"
+        dict << "/BlueFuzz 1 def"
+
+        # Stem snap hints
+        os2 = @font.table(Constants::OS2_TAG)
+        if os2.respond_to?(:weight_class)
+          stem_width = @scaler.scale([100, 80,
+                                      90][os2.weight_class / 100] || 80)
+          dict << "/StemSnapH [#{stem_width}] def"
+          dict << "/StemSnapV [#{stem_width}] def"
+        end
+
+        # Force bold flag
+        dict << if os2.respond_to?(:weight_class) && os2.weight_class && os2.weight_class >= 700
+                  "/ForceBold true def"
+                else
+                  "/ForceBold false def"
+                end
+
+        # Language group
+        dict << "/LanguageGroup 0 def"
+
+        # Unique ID (random)
+        dict << "/UniqueID #{rand(1000000..9999999)} def"
+
+        dict << "currentdict end"
+        dict << "dup /Private get"
+
+        dict.join("\n")
+      end
+
+      # Build CharStrings dictionary
+      #
+      # @return [String] CharStrings dictionary reference
+      def build_charstrings_dict
+        # This is a placeholder - actual CharStrings are in the binary segment
+        "/CharStrings #{@charstrings&.size || 0} dict dup begin\nend"
+      end
+
+      # Build CharStrings dictionary text for eexec encryption
+      #
+      # @param charstrings [Hash] Glyph ID to CharString mapping
+      # @return [String] CharStrings dictionary text
+      def build_charstrings_dict_text(charstrings)
+        lines = []
+        lines << "dup /FontName get exch definefont pop"
+        lines << "begin"
+        lines << "/CharStrings #{charstrings.size} dict dup begin"
+
+        charstrings.each do |gid, charstring|
+          # Convert charstring bytes to hex representation for PostScript
+          hex_data = charstring.unpack1("H*")
+          lines << "#{gid} #{charstring.bytesize} #{hex_data} RD"
+        end
+
+        lines << "end"
+        lines << "end"
+        lines << "put"
+        lines.join("\n")
+      end
+
+      # Build binary segment (CharStrings)
+      #
+      # @return [String] Binary CharString data (encrypted with eexec)
+      def build_binary_segment
+        # Convert glyphs to Type 1 CharStrings
+        charstrings = if @convert_curves
+                        TTFToType1Converter.convert(@font, @scaler, @encoding)
+                      else
+                        # For simple curve conversion skip, generate minimal charstrings
+                        generate_simple_charstrings
+                      end
+
+        # Build CharStrings dictionary text
+        charstrings_dict = build_charstrings_dict_text(charstrings)
+
+        # Encrypt with eexec
+        Decryptor.eexec_encrypt(charstrings_dict)
+      end
+
+      # Generate simple CharStrings (without curve conversion)
+      #
+      # @return [Hash<Integer, String>] Glyph ID to CharString mapping
+      def generate_simple_charstrings
+        glyf_table = @font.table(Constants::GLYF_TAG)
+        return {} unless glyf_table
+
+        maxp = @font.table(Constants::MAXP_TAG)
+        num_glyphs = maxp&.num_glyphs || 0
+
+        charstrings = {}
+        num_glyphs.times do |gid|
+          charstrings[gid] = simple_charstring(glyf_table, gid)
+        end
+
+        charstrings
+      end
+
+      # Generate a simple CharString for a glyph
+      #
+      # @param glyf_table [Object] TTF glyf table
+      # @param gid [Integer] Glyph ID
+      # @return [String] Type 1 CharString data
+      def simple_charstring(glyf_table, gid)
+        glyph = glyf_table.glyph(gid)
+
+        # Empty or compound glyph
+        if glyph.nil? || glyph.contour_count.zero? || glyph.compound?
+          # Return empty charstring (hsbw + endchar)
+          return [0, 500, 14].pack("C*")
+        end
+
+        # For simple glyphs without curve conversion, generate line-based charstring
+        # This is a simplified implementation
+        lsb = @scaler.scale(glyph.left_side_bearing || 0)
+        width = @scaler.scale(glyph.advance_width || 500)
+        bytes = [0, lsb, width] # hsbw
+
+        # Add lines between points (simplified)
+        if glyph.respond_to?(:points) && glyph.points && !glyph.points.empty?
+          glyph.points.each do |point|
+            next unless point.on_curve?
+
+            # This is very simplified - proper implementation would handle curves
+          end
+        end
+
+        bytes << 14 # endchar
+        bytes.pack("C*")
+      end
+
+      # Build second ASCII segment (trailer)
+      #
+      # @return [String] ASCII trailer
+      def build_ascii_segment_2
+        lines = []
+        lines << "put" # Put the Private dictionary
+        lines << "dup /FontName get exch definefont pop"
+        lines << "% cleartomark"
+        lines.join("\n")
+      end
+
+      # Create PFB segment header
+      #
+      # @param marker [Integer] Segment type marker
+      # @param size [Integer] Segment data size
+      # @return [String] 6-byte segment header
+      def segment_header(marker, size)
+        [marker, size].pack("CV")
+      end
+    end
+  end
+end

data/lib/fontisan/type1/pfb_parser.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Type1
+    # Parser for PFB (Printer Font Binary) format
+    #
+    # [`PFBParser`](lib/fontisan/type1/pfb_parser.rb) parses the binary PFB format
+    # used for storing Adobe Type 1 fonts, primarily on Windows systems.
+    #
+    # The PFB format consists of binary chunks marked with special codes:
+    # - 0x8001: ASCII text chunk
+    # - 0x8002: Binary data chunk (usually encrypted)
+    # - 0x8003: End of file marker
+    #
+    # Each chunk (except EOF) has a 4-byte little-endian length prefix.
+    #
+    # @example Parse a PFB file
+    #   parser = Fontisan::Type1::PFBParser.new
+    #   result = parser.parse(File.binread('font.pfb'))
+    #   puts result.ascii_parts    # => ["%!PS-AdobeFont-1.0...", ...]
+    #   puts result.binary_parts   # => [encrypted_binary_data, ...]
+    #
+    # @see https://www.adobe.com/devnet/font/pdfs/Type1.pdf
+    class PFBParser
+      # PFB chunk markers
+      ASCII_CHUNK = 0x8001
+      BINARY_CHUNK = 0x8002
+      EOF_CHUNK = 0x8003
+
+      # @return [Array<String>] ASCII text parts
+      attr_reader :ascii_parts
+
+      # @return [Array<String>] Binary data parts
+      attr_reader :binary_parts
+
+      # Parse PFB format data
+      #
+      # @param data [String] Binary PFB data
+      # @return [PFBParser] Self for method chaining
+      # @raise [ArgumentError] If data is nil or empty
+      # @raise [Fontisan::Error] If PFB format is invalid
+      def parse(data)
+        raise ArgumentError, "Data cannot be nil" if data.nil?
+        raise ArgumentError, "Data cannot be empty" if data.empty?
+
+        @ascii_parts = []
+        @binary_parts = []
+
+        offset = 0
+        chunk_index = 0
+
+        while offset < data.length
+          # Check for chunk marker (must have at least 2 bytes)
+          if offset + 2 > data.length
+            raise Fontisan::Error,
+                  "Invalid PFB: incomplete chunk header at offset #{offset}"
+          end
+
+          # Read chunk marker (big-endian)
+          marker = (data.getbyte(offset) << 8) |
+            data.getbyte(offset + 1)
+          offset += 2
+
+          case marker
+          when ASCII_CHUNK
+            chunk = read_chunk(data, offset, chunk_index, "ASCII")
+            @ascii_parts << chunk[:data]
+            offset = chunk[:next_offset]
+            chunk_index += 1
+
+          when BINARY_CHUNK
+            chunk = read_chunk(data, offset, chunk_index, "binary")
+            @binary_parts << chunk[:data]
+            offset = chunk[:next_offset]
+            chunk_index += 1
+
+          when EOF_CHUNK
+            # End of file - no more chunks
+            break
+
+          else
+            raise Fontisan::Error,
+                  "Invalid PFB: unknown chunk marker 0x#{marker.to_s(16).upcase} at offset #{offset - 2}"
+          end
+        end
+
+        self
+      end
+
+      # Get all ASCII parts concatenated
+      #
+      # @return [String] All ASCII parts joined together
+      def ascii_text
+        @ascii_parts.join
+      end
+
+      # Get all binary parts concatenated
+      #
+      # @return [String] All binary parts joined together
+      def binary_data
+        @binary_parts.join
+      end
+
+      # Check if parser has parsed data
+      #
+      # @return [Boolean] True if data has been parsed
+      def parsed?
+        !@ascii_parts.nil? && !@binary_parts.nil?
+      end
+
+      # Check if this appears to be a PFB file
+      #
+      # @param data [String] Binary data to check
+      # @return [Boolean] True if data starts with PFB marker
+      #
+      # @example Check if file is PFB format
+      #   if Fontisan::Type1::PFBParser.pfb_file?(data)
+      #     # Handle PFB format
+      #   end
+      def self.pfb_file?(data)
+        return false if data.nil? || data.length < 2
+
+        # PFB marker is big-endian (first byte is high byte)
+        marker = (data.getbyte(0) << 8) | data.getbyte(1)
+        [ASCII_CHUNK, BINARY_CHUNK].include?(marker)
+      end
+
+      private
+
+      # Read a chunk from PFB data
+      #
+      # @param data [String] PFB binary data
+      # @param offset [Integer] Current offset in data
+      # @param chunk_index [Integer] Index of current chunk (for error messages)
+      # @param type [String] Type of chunk ("ASCII" or "binary")
+      # @return [Hash] Chunk data with :data and :next_offset
+      def read_chunk(data, offset, chunk_index, type)
+        # Read 4-byte length (little-endian)
+        if offset + 4 > data.length
+          raise Fontisan::Error,
+                "Invalid PFB: incomplete length for #{type} chunk #{chunk_index}"
+        end
+
+        length = data.getbyte(offset) |
+          (data.getbyte(offset + 1) << 8) |
+          (data.getbyte(offset + 2) << 16) |
+          (data.getbyte(offset + 3) << 24)
+        offset += 4
+
+        # Read chunk data
+        if offset + length > data.length
+          raise Fontisan::Error,
+                "Invalid PFB: #{type} chunk #{chunk_index} length #{length} exceeds remaining data"
+        end
+
+        chunk_data = data.byteslice(offset, length)
+        next_offset = offset + length
+
+        {
+          data: chunk_data,
+          next_offset: next_offset,
+        }
+      end
+    end
+  end
+end