pdf-reader 1.1.1 → 1.2.0

data/lib/pdf/reader/filter/ascii85.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+
+require 'ascii85'
+
+class PDF::Reader
+  module Filter # :nodoc:
+    class Ascii85
+      def initialize(options = {})
+        @options = options
+      end
+
+      ################################################################################
+      # Decode the specified data using the Ascii85 algorithm. Relies on the AScii85
+      # rubygem.
+      #
+      def filter(data)
+        data = "<~#{data}" unless data.to_s[0,2] == "<~"
+        ::Ascii85::decode(data)
+      rescue Exception => e
+        # Oops, there was a problem decoding the stream
+        raise MalformedPDFError, "Error occured while decoding an ASCII85 stream (#{e.class.to_s}: #{e.to_s})"
+      end
+    end
+  end
+end

data/lib/pdf/reader/filter/ascii_hex.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+#
+class PDF::Reader
+  module Filter # :nodoc:
+    class AsciiHex
+      def initialize(options = {})
+        @options = options
+      end
+
+      ################################################################################
+      # Decode the specified data using the AsciiHex algorithm.
+      #
+      def filter(data)
+        data.chop! if data[-1,1] == ">"
+        data = data[1,data.size] if data[0,1] == "<"
+        data.gsub!(/[^A-Fa-f0-9]/,"")
+        data << "0" if data.size % 2 == 1
+        data.scan(/.{2}/).map { |s| s.hex.chr }.join("")
+      rescue Exception => e
+        # Oops, there was a problem decoding the stream
+        raise MalformedPDFError, "Error occured while decoding an ASCIIHex stream (#{e.class.to_s}: #{e.to_s})"
+      end
+    end
+  end
+end
+

data/lib/pdf/reader/filter/depredict.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+
+class PDF::Reader
+  module Filter # :nodoc:
+    class Depredict
+      def initialize(options = {})
+        @options = options || {}
+      end
+
+      ################################################################################
+      # Streams can be preprocessed to improve compression. This reverses the
+      # preprocessing
+      #
+      def filter(data)
+        predictor = @options[:Predictor].to_i
+
+        case predictor
+        when 0, 1 then
+          data
+        when 2    then
+          tiff_depredict(data)
+        when 10, 11, 12, 13, 14, 15 then
+          png_depredict(data)
+        else
+          raise  MalformedPDFError, "Unrecognised predictor value (#{predictor})"
+        end
+      end
+
+      private
+
+      ################################################################################
+      def tiff_depredict(data)
+        data        = data.unpack("C*")
+        unfiltered  = []
+        bpc         = @options[:BitsPerComponent] || 8
+        pixel_bits  = bpc * @options[:Colors]
+        pixel_bytes = pixel_bits / 8
+        line_len    = (pixel_bytes * @options[:Columns])
+        pos         = 0
+
+        if bpc != 8
+          raise UnsupportedFeatureError, "TIFF predictor onlys supports 8 Bits Per Component"
+        end
+
+        until pos > data.size
+          row_data = data[pos, line_len]
+          row_data.each_with_index do |byte, index|
+            left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+            row_data[index] = (byte + left) % 256
+          end
+          unfiltered += row_data
+          pos += line_len
+        end
+
+        unfiltered.pack("C*")
+      end
+      ################################################################################
+      def png_depredict(data)
+        return data if @options[:Predictor].to_i < 10
+
+        data = data.unpack("C*")
+
+        pixel_bytes     = @options[:Colors] || 1
+        scanline_length = (pixel_bytes * @options[:Columns]) + 1
+        row = 0
+        pixels = []
+        paeth, pa, pb, pc = nil
+        until data.empty? do
+          row_data = data.slice! 0, scanline_length
+          filter = row_data.shift
+          case filter
+          when 0 # None
+          when 1 # Sub
+            row_data.each_with_index do |byte, index|
+              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+              row_data[index] = (byte + left) % 256
+              #p [byte, left, row_data[index]]
+            end
+          when 2 # Up
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_bytes
+              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
+              row_data[index] = (upper + byte) % 256
+            end
+          when 3  # Average
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_bytes
+              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
+              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+
+              row_data[index] = (byte + ((left + upper)/2).floor) % 256
+            end
+          when 4 # Paeth
+            left = upper = upper_left = nil
+            row_data.each_with_index do |byte, index|
+              col = index / pixel_bytes
+
+              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
+              if row.zero?
+                upper = upper_left = 0
+              else
+                upper = pixels[row-1][col][index % pixel_bytes]
+                upper_left = col.zero? ? 0 :
+                  pixels[row-1][col-1][index % pixel_bytes]
+              end
+
+              p = left + upper - upper_left
+              pa = (p - left).abs
+              pb = (p - upper).abs
+              pc = (p - upper_left).abs
+
+              paeth = if pa <= pb && pa <= pc
+                        left
+                      elsif pb <= pc
+                        upper
+                      else
+                        upper_left
+                      end
+
+              row_data[index] = (byte + paeth) % 256
+            end
+          else
+            raise ArgumentError, "Invalid filter algorithm #{filter}"
+          end
+
+          s = []
+          row_data.each_slice pixel_bytes do |slice|
+            s << slice
+          end
+          pixels << s
+          row += 1
+        end
+
+        pixels.map { |bytes| bytes.flatten.pack("C*") }.join("")
+      end
+    end
+  end
+end

data/lib/pdf/reader/filter/flate.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+
+
+require 'zlib'
+
+class PDF::Reader
+  module Filter # :nodoc:
+    class Flate
+      def initialize(options = {})
+        @options = options
+      end
+
+      ################################################################################
+      # Decode the specified data with the Zlib compression algorithm
+      def filter(data)
+        deflated = nil
+        begin
+          deflated = Zlib::Inflate.new.inflate(data)
+        rescue Zlib::DataError => e
+          # by default, Ruby's Zlib assumes the data it's inflating
+          # is RFC1951 deflated data, wrapped in a RFC1951 zlib container.
+          # If that fails, then use an undocumented 'feature' to attempt to inflate
+          # the data as a raw RFC1951 stream.
+          #
+          # See
+          # - http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/243545
+          # - http://www.gzip.org/zlib/zlib_faq.html#faq38
+          deflated = Zlib::Inflate.new(-Zlib::MAX_WBITS).inflate(data)
+        end
+        Depredict.new(@options).filter(deflated)
+      rescue Exception => e
+        # Oops, there was a problem inflating the stream
+        raise MalformedPDFError, "Error occured while inflating a compressed stream (#{e.class.to_s}: #{e.to_s})"
+      end
+    end
+  end
+end
+

data/lib/pdf/reader/filter/lzw.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+#
+class PDF::Reader
+  module Filter # :nodoc:
+    class Lzw
+      def initialize(options = {})
+        @options = options
+      end
+
+      ################################################################################
+      # Decode the specified data with the LZW compression algorithm
+      def filter(data)
+        data = PDF::Reader::LZW.decode(data)
+        Depredict.new(@options).filter(data)
+      end
+    end
+  end
+end

data/lib/pdf/reader/filter/null.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+#
+class PDF::Reader
+  module Filter # :nodoc:
+    class Null
+      def initialize(options = {})
+        @options = options
+      end
+
+      def filter(data)
+        data
+      end
+    end
+  end
+end

data/lib/pdf/reader/filter/run_length.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+#
+class PDF::Reader
+  module Filter # :nodoc:
+    class RunLength
+      def initialize(options = {})
+        @options = options
+      end
+
+      ################################################################################
+      # Decode the specified data with the RunLengthDecode compression algorithm
+      def filter(data)
+        pos = 0
+        out = ""
+
+        while pos < data.length
+          if data.respond_to?(:getbyte)
+            length = data.getbyte(pos)
+          else
+            length = data[pos]
+          end
+          pos += 1
+
+          case
+          when length == 128
+            break
+          when length < 128
+            # When the length is < 128, we copy the following length+1 bytes
+            # literally.
+            out << data[pos, length + 1]
+            pos += length
+          else
+            # When the length is > 128, we copy the next byte (257 - length)
+            # times; i.e., "\xFA\x00" ([250, 0]) will expand to
+            # "\x00\x00\x00\x00\x00\x00\x00".
+            out << data[pos, 1] * (257 - length)
+          end
+
+          pos += 1
+        end
+
+        Depredict.new(@options).filter(out)
+      end
+    end
+  end
+end

data/lib/pdf/reader/font.rb

@@ -109,7 +109,7 @@ class PDF::Reader
       if params.class == String
         params.unpack(encoding.unpack).map { |c|
           @tounicode.decode(c) || PDF::Reader::Encoding::UNKNOWN_CHAR
-        }.pack("U*")
+        }.flatten.pack("U*")
       elsif params.class == Array
         params.collect { |param| to_utf8_via_cmap(param) }
       else

data/lib/pdf/reader/form_xobject.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'digest/md5'
+
 module PDF
   class Reader
 
@@ -15,9 +17,10 @@ module PDF
 
       attr_reader :xobject
 
-      def initialize(page, xobject)
+      def initialize(page, xobject, options = {})
         @page    = page
         @objects = page.objects
+        @cache   = options[:cache] || {}
         @xobject = @objects.deref(xobject)
       end
 
@@ -65,12 +68,30 @@ module PDF
         end
       end
 
+      def content_stream_md5
+        @content_stream_md5 ||= Digest::MD5.hexdigest(raw_content)
+      end
+
+      def cached_tokens_key
+        @cached_tokens_key ||= "tokens-#{content_stream_md5}"
+      end
+
+      def tokens
+        @cache[cached_tokens_key] ||= begin
+                      buffer = Buffer.new(StringIO.new(raw_content), :content_stream => true)
+                      parser = Parser.new(buffer, @objects)
+                      result = []
+                      while (token = parser.parse_token(PagesStrategy::OPERATORS))
+                        result << token
+                      end
+                      result
+                    end
+      end
+
       def content_stream(receivers, instructions)
-        buffer       = Buffer.new(StringIO.new(instructions), :content_stream => true)
-        parser       = Parser.new(buffer, @objects)
         params       = []
 
-        while (token = parser.parse_token(PagesStrategy::OPERATORS))
+        tokens.each do |token|
           if token.kind_of?(Token) and PagesStrategy::OPERATORS.has_key?(token)
             callback(receivers, PagesStrategy::OPERATORS[token], params)
             params.clear

data/lib/pdf/reader/glyph_hash.rb

@@ -26,7 +26,8 @@
 class PDF::Reader
   class GlyphHash # :nodoc:
     def initialize
-      @adobe = load_adobe_glyph_mapping
+      # only parse the glyph list once, and cache the results (for performance)
+      @adobe = @@cache ||= load_adobe_glyph_mapping
     end
 
     # attempt to convert a PDF Name to a unicode codepoint. Returns nil
@@ -82,7 +83,7 @@ class PDF::Reader
         end
       end
 
-      glyphs
+      glyphs.freeze
     end
 
   end

data/lib/pdf/reader/object_cache.rb

@@ -1,10 +1,12 @@
 # coding: utf-8
 
+require 'hashery'
+
 class PDF::Reader
 
   # A Hash-like object for caching commonly used objects from a PDF file.
   #
-  # This is an internal class used by PDF::Reader::ObjectHash
+  # This is an internal class, no promises about a stable API.
   #
   class ObjectCache # nodoc
 
@@ -13,53 +15,67 @@ class PDF::Reader
     # avoid lots of repetitive (and expensive) tokenising
     CACHEABLE_TYPES = [:Catalog, :Page, :Pages]
 
-    def initialize
+    attr_reader :hits, :misses
+
+    def initialize(lru_size = 1000)
       @objects = {}
+      @lru_cache = Hashery::LRUHash.new(lru_size.to_i)
+      @hits = 0
+      @misses = 0
     end
 
     def [](key)
-      @objects[key]
+      update_stats(key)
+      @objects[key] || @lru_cache[key]
     end
 
     def []=(key, value)
-      @objects[key] = value if cacheable?(value)
+      if cacheable?(value)
+        @objects[key] = value
+      else
+        @lru_cache[key] = value
+      end
     end
 
     def fetch(key, local_default = nil)
-      @objects.fetch(key, local_default)
+      update_stats(key)
+      @objects[key] || @lru_cache.fetch(key, local_default)
     end
 
     def each(&block)
       @objects.each(&block)
+      @lru_cache.each(&block)
     end
     alias :each_pair :each
 
     def each_key(&block)
       @objects.each_key(&block)
+      @lru_cache.each_key(&block)
     end
 
     def each_value(&block)
       @objects.each_value(&block)
+      @lru_cache.each_value(&block)
     end
 
     def size
-      @objects.size
+      @objects.size + @lru_cache.size
     end
     alias :length :size
 
     def empty?
-      @objects.empty?
+      @objects.empty? && @lru_cache.empty?
     end
 
-    def has_key?(key)
-      @objects.has_key?(key)
+    def include?(key)
+      @objects.include?(key) || @lru_cache.include?(key)
     end
-    alias :include? :has_key?
-    alias :key? :has_key?
-    alias :member? :has_key?
+    alias :has_key? :include?
+    alias :key? :include?
+    alias :member? :include?
 
     def has_value?(value)
-      @objects.has_value?(value)
+      @objects.has_value?(value) || @lru_cache.has_value?(value)
     end
 
     def to_s
@@ -67,19 +83,26 @@ class PDF::Reader
     end
 
     def keys
-      @objects.keys
+      @objects.keys + @lru_cache.keys
     end
 
     def values
-      @objects.values
+      @objects.values + @lru_cache.values
     end
 
     private
 
+    def update_stats(key)
+      if has_key?(key)
+        @hits += 1
+      else
+        @misses += 1
+      end
+    end
+
     def cacheable?(obj)
       obj.is_a?(Hash) && CACHEABLE_TYPES.include?(obj[:Type])
     end
 
-
   end
 end