hexapdf 0.1.0

data/lib/hexapdf/filter/lzw_decode.rb

@@ -0,0 +1,191 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF 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 Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'fiber'
+require 'hexapdf/utils/bit_stream'
+require 'hexapdf/filter/predictor'
+require 'hexapdf/error'
+
+module HexaPDF
+  module Filter
+
+    # Implements the LZW filter.
+    #
+    # Since LZW uses a tightly packed bit stream in which codes are of varying bit lengths and are
+    # not aligned to byte boundaries, this filter is not as fast as the other filters. If speed is
+    # a concern, the FlateDecode filter should be used instead.
+    #
+    # See: HexaPDF::Filter, PDF1.7 s7.4.4
+    module LZWDecode
+
+      CLEAR_TABLE = 256 # :nodoc:
+      EOD = 257 # :nodoc:
+
+      INITIAL_ENCODER_TABLE = {} #:nodoc:
+      0.upto(255) {|i| INITIAL_ENCODER_TABLE[i.chr.freeze] = i}
+      INITIAL_ENCODER_TABLE[CLEAR_TABLE] = CLEAR_TABLE
+      INITIAL_ENCODER_TABLE[EOD] = EOD
+
+      INITIAL_DECODER_TABLE = {} #:nodoc:
+      0.upto(255) {|i| INITIAL_DECODER_TABLE[i] = i.chr}
+      INITIAL_DECODER_TABLE[CLEAR_TABLE] = CLEAR_TABLE
+      INITIAL_DECODER_TABLE[EOD] = EOD
+
+      # See HexaPDF::Filter
+      def self.decoder(source, options = nil)
+        fib = Fiber.new do
+          # initialize decoder state
+          code_length = 9
+          table = INITIAL_DECODER_TABLE.dup
+
+          stream = HexaPDF::Utils::BitStreamReader.new
+          result = ''.b
+          finished = false
+          last_code = CLEAR_TABLE
+
+          while !finished && source.alive? && (data = source.resume)
+            stream.append_data(data)
+
+            while stream.read?(code_length)
+              code = stream.read(code_length)
+
+              # Decoder is one step behind => subtract 1!
+              # We check the table size before entering the next code into it => subtract 1, but
+              # there is one exception: After table entry 4095 is written, the clear table code
+              # also gets written with code length 12,
+              case table.size
+              when 510, 1022, 2046
+                code_length += 1
+              when 4095
+                if code != CLEAR_TABLE
+                  raise FilterError, "Maximum of 12bit for codes in LZW stream exceeded"
+                end
+              end
+
+              if code == EOD
+                finished = true
+                break
+              elsif code == CLEAR_TABLE
+                # reset decoder state
+                code_length = 9
+                table = INITIAL_DECODER_TABLE.dup
+              elsif last_code == CLEAR_TABLE
+                unless table.key?(code)
+                  raise FilterError, "Unknown code in LZW encoded stream found"
+                end
+                result << table[code]
+              else
+                unless table.key?(last_code)
+                  raise FilterError, "Unknown code in LZW encoded stream found"
+                end
+                last_str = table[last_code]
+
+                str = if table.key?(code)
+                        table[code]
+                      else
+                        last_str + last_str[0]
+                      end
+                result << str
+                table[table.size] = last_str + str[0]
+              end
+
+              last_code = code
+            end
+
+            Fiber.yield(result)
+            result = ''.b
+          end
+        end
+
+        if options && options[:Predictor]
+          Predictor.decoder(fib, options)
+        else
+          fib
+        end
+      end
+
+      # See HexaPDF::Filter
+      def self.encoder(source, options = nil)
+        if options && options[:Predictor]
+          source = Predictor.encoder(source, options)
+        end
+
+        Fiber.new do
+          # initialize encoder state
+          code_length = 9
+          table = INITIAL_ENCODER_TABLE.dup
+
+          # initialize the bit stream with the clear-table marker
+          stream = HexaPDF::Utils::BitStreamWriter.new
+          result = stream.write(CLEAR_TABLE, 9)
+          str = ''.b
+
+          while source.alive? && (data = source.resume)
+            data.each_char do |char|
+              newstr = str + char
+              if table.key?(newstr)
+                str = newstr
+              else
+                result << stream.write(table[str], code_length)
+                table[newstr.freeze] = table.size
+                str = char
+              end
+
+              case table.size
+              when 512 then code_length = 10
+              when 1024 then code_length = 11
+              when 2048 then code_length = 12
+              when 4096
+                result << stream.write(CLEAR_TABLE, code_length)
+                # reset encoder state
+                code_length = 9
+                table = INITIAL_ENCODER_TABLE.dup
+              end
+            end
+
+            Fiber.yield(result)
+            result = ''.b
+          end
+
+          result = stream.write(table[str], code_length)
+          result << stream.write(EOD, code_length)
+          result << stream.finalize
+
+          result
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/filter/predictor.rb

@@ -0,0 +1,266 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF 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 Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'fiber'
+require 'hexapdf/error'
+require 'hexapdf/utils/bit_stream'
+
+module HexaPDF
+  module Filter
+
+    # Implements the predictor for the LZWDecode and FlateDecode filters.
+    #
+    # Although a predictor isn't a full PDF filter, it is implemented as one in HexaPDF terms to
+    # allow easy chaining of the predictor.
+    #
+    # See: PDF1.7 s7.4.4.3, s7.4.4.4, https://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf
+    # (p64f), http://www.w3.org/TR/PNG-Filters.html
+    #
+    #-- Implemenation notes:
+    #
+    # The TIFF encoding and decoding methods are the same, except for the innermost loop. The way
+    # it is implemented is probably not the best but it avoids duplicate code.
+    #
+    # The situation is similar with PNG encoding and decoding.
+    #++
+    module Predictor
+
+      PREDICTOR_PNG_NONE = 0    #:nodoc:
+      PREDICTOR_PNG_SUB = 1     #:nodoc:
+      PREDICTOR_PNG_UP = 2      #:nodoc:
+      PREDICTOR_PNG_AVERAGE = 3 #:nodoc:
+      PREDICTOR_PNG_PAETH = 4   #:nodoc:
+      PREDICTOR_PNG_OPTIMUM = 5 #:nodoc:
+
+      # See HexaPDF::Filter
+      def self.decoder(source, options)
+        execute(:decoder, source, options)
+      end
+
+      # See HexaPDF::Filter
+      def self.encoder(source, options)
+        execute(:encoder, source, options)
+      end
+
+      def self.execute(type, source, options) # :nodoc:
+        return source if !options[:Predictor] || options[:Predictor] == 1
+
+        colors = options[:Colors] || 1
+        bits_per_component = options[:BitsPerComponent] || 8
+        columns = options[:Columns] || 1
+
+        if options[:Predictor] == 2
+          tiff_execute(type, source, colors, bits_per_component, columns)
+        elsif options[:Predictor] >= 10
+          png_execute(type, source, options[:Predictor], colors, bits_per_component, columns)
+        else
+          raise HexaPDF::InvalidPDFObjectError, "Predictor key is invalid: #{options[:Predictor]}"
+        end
+      end
+
+      def self.tiff_execute(type, source, colors, bits_per_component, columns) # :nodoc:
+        Fiber.new do
+          bytes_per_row = (columns * bits_per_component * colors + 7) / 8
+          mask = (1 << bits_per_component) - 1
+
+          data = ''.b
+          writer = HexaPDF::Utils::BitStreamWriter.new
+          pos = 0
+
+          decode_row = lambda do |result, reader|
+            last_components = [0] * colors
+            (columns * colors).times do |i|
+              i %= colors
+              tmp = (reader.read(bits_per_component) + last_components[i]) & mask
+              result << writer.write(tmp, bits_per_component)
+              last_components[i] = tmp
+            end
+            result << writer.finalize
+          end
+
+          encode_row = lambda do |result, reader|
+            last_components = [0] * colors
+            (columns * colors).times do |i|
+              i %= colors
+              tmp = reader.read(bits_per_component)
+              result << writer.write((tmp - last_components[i]) & mask, bits_per_component)
+              last_components[i] = tmp
+            end
+            result << writer.finalize
+          end
+
+          row_action = (type == :decoder ? decode_row : encode_row)
+
+          while source.alive? && (new_data = source.resume)
+            data.slice!(0...pos)
+            data << new_data
+
+            result = ''.b
+            pos = 0
+
+            while pos + bytes_per_row <= data.length
+              reader = HexaPDF::Utils::BitStreamReader.new(data[pos, bytes_per_row])
+              row_action.call(result, reader)
+              pos += bytes_per_row
+            end
+
+            Fiber.yield(result) unless result.empty?
+          end
+
+          unless pos == data.length
+            raise FilterError, "Data is missing for TIFF predictor"
+          end
+        end
+      end
+
+      def self.png_execute(type, source, predictor, colors, bits_per_component, columns) # :nodoc:
+        Fiber.new do
+          bytes_per_pixel = (bits_per_component * colors + 7) / 8
+          bytes_per_row = (columns * bits_per_component * colors + 7) / 8
+          bytes_per_row += 1 if type == :decoder
+
+          # Only on encoding: Arbitrarily choose a predictor if we should choose the optimum
+          predictor = predictor == 15 ? PREDICTOR_PNG_PAETH : predictor - 10
+
+          data = ''.b
+          last_line = "\0".b * (bytes_per_row + 1)
+          pos = 0
+
+          decode_row = lambda do |result|
+            line = data[pos, bytes_per_row]
+
+            case line.getbyte(0)
+            when PREDICTOR_PNG_NONE
+              # nothing to do
+            when PREDICTOR_PNG_SUB
+              (bytes_per_pixel + 1).upto(bytes_per_row - 1) do |i|
+                line.setbyte(i, line.getbyte(i) + line.getbyte(i - bytes_per_pixel))
+              end
+            when PREDICTOR_PNG_UP
+              1.upto(bytes_per_row - 1) do |i|
+                line.setbyte(i, line.getbyte(i) + last_line.getbyte(i))
+              end
+            when PREDICTOR_PNG_AVERAGE
+              1.upto(bytes_per_row - 1) do |i|
+                a = i <= bytes_per_pixel ? 0 : line.getbyte(i - bytes_per_pixel)
+                line.setbyte(i, line.getbyte(i) + ((a + last_line.getbyte(i)) >> 1))
+              end
+            when PREDICTOR_PNG_PAETH
+              1.upto(bytes_per_row - 1) do |i|
+                a = i <= bytes_per_pixel ? 0 : line.getbyte(i - bytes_per_pixel)
+                b = last_line.getbyte(i)
+                c = i <= bytes_per_pixel ? 0 : last_line.getbyte(i - bytes_per_pixel)
+
+                point = a + b - c
+                pa = (point - a).abs
+                pb = (point - b).abs
+                pc = (point - c).abs
+
+                point = ((pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c))
+
+                line.setbyte(i, line.getbyte(i) + point)
+              end
+            end
+
+            result << line[1..-1]
+            last_line = line
+          end
+
+          encode_row = lambda do |result|
+            line = predictor.chr.force_encoding(Encoding::BINARY) << data[pos, bytes_per_row]
+            next_last_line = line.dup
+
+            case predictor
+            when PREDICTOR_PNG_NONE
+              # nothing to do
+            when PREDICTOR_PNG_SUB
+              bytes_per_row.downto(bytes_per_pixel + 1) do |i|
+                line.setbyte(i, line.getbyte(i) - line.getbyte(i - bytes_per_pixel))
+              end
+            when PREDICTOR_PNG_UP
+              bytes_per_row.downto(1) do |i|
+                line.setbyte(i, line.getbyte(i) - last_line.getbyte(i))
+              end
+            when PREDICTOR_PNG_AVERAGE
+              bytes_per_row.downto(1) do |i|
+                a = i <= bytes_per_pixel ? 0 : line.getbyte(i - bytes_per_pixel)
+                line.setbyte(i, line.getbyte(i) - ((a + last_line.getbyte(i)) >> 1))
+              end
+            when PREDICTOR_PNG_PAETH
+              bytes_per_row.downto(1) do |i|
+                a = i <= bytes_per_pixel ? 0 : line.getbyte(i - bytes_per_pixel)
+                b = last_line.getbyte(i)
+                c = i <= bytes_per_pixel ? 0 : last_line.getbyte(i - bytes_per_pixel)
+
+                point = a + b - c
+                pa = (point - a).abs
+                pb = (point - b).abs
+                pc = (point - c).abs
+
+                point = ((pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c))
+
+                line.setbyte(i, line.getbyte(i) - point)
+              end
+            end
+
+            result << line
+            last_line = next_last_line
+          end
+
+          row_action = (type == :decoder ? decode_row : encode_row)
+
+          while source.alive? && (new_data = source.resume)
+            data.slice!(0...pos)
+            data << new_data
+
+            result = ''.b
+            pos = 0
+
+            while pos + bytes_per_row <= data.length
+              row_action.call(result)
+              pos += bytes_per_row
+            end
+
+            Fiber.yield(result) unless result.empty?
+          end
+
+          unless pos == data.length
+            raise FilterError, "Data is missing for PNG predictor"
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/hexapdf/filter/run_length_decode.rb

@@ -0,0 +1,108 @@
+# -*- encoding: utf-8 -*-
+#
+#--
+# This file is part of HexaPDF.
+#
+# HexaPDF - A Versatile PDF Creation and Manipulation Library For Ruby
+# Copyright (C) 2016 Thomas Leitner
+#
+# HexaPDF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU Affero General Public License version 3 as
+# published by the Free Software Foundation with the addition of the
+# following permission added to Section 15 as permitted in Section 7(a):
+# FOR ANY PART OF THE COVERED WORK IN WHICH THE COPYRIGHT IS OWNED BY
+# THOMAS LEITNER, THOMAS LEITNER DISCLAIMS THE WARRANTY OF NON
+# INFRINGEMENT OF THIRD PARTY RIGHTS.
+#
+# HexaPDF 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 Affero General Public
+# License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with HexaPDF. If not, see <http://www.gnu.org/licenses/>.
+#
+# The interactive user interfaces in modified source and object code
+# versions of HexaPDF must display Appropriate Legal Notices, as required
+# under Section 5 of the GNU Affero General Public License version 3.
+#
+# In accordance with Section 7(b) of the GNU Affero General Public
+# License, a covered work must retain the producer line in every PDF that
+# is created or manipulated using HexaPDF.
+#++
+
+require 'fiber'
+require 'strscan'
+require 'hexapdf/error'
+
+module HexaPDF
+  module Filter
+
+    # Implements the run length filter.
+    #
+    # See: HexaPDF::Filter, PDF1.7 s7.4.5
+    module RunLengthDecode
+
+      EOD = 128.chr #:nodoc:
+
+      # See HexaPDF::Filter
+      def self.decoder(source, _ = nil)
+        Fiber.new do
+          i = 0
+          result = ''.b
+          data = source.resume
+          while data && i < data.length
+            length = data.getbyte(i)
+            if length < 128 && i + length + 1 < data.length # no byte run and enough bytes
+              result << data[i + 1, length + 1]
+              i += length + 2
+            elsif length > 128 && i + 1 < data.length # byte run and enough bytes
+              result << data[i + 1] * (257 - length)
+              i += 2
+            elsif length != 128 # not enough bytes in data
+              Fiber.yield(result)
+              if source.alive? && (new_data = source.resume)
+                data = data[i..-1] << new_data
+              else
+                raise FilterError, "Missing data for run length encoded stream"
+              end
+              i = 0
+              result = ''.b
+            else # EOD reached
+              break
+            end
+
+            if i == data.length && source.alive? && (data = source.resume)
+              Fiber.yield(result)
+              i = 0
+              result = ''.b
+            end
+          end
+          result unless result.empty?
+        end
+      end
+
+      # See HexaPDF::Filter
+      def self.encoder(source, _ = nil)
+        Fiber.new do
+          while source.alive? && (data = source.resume)
+            result = ''.b
+            strscan = StringScanner.new(data)
+            until strscan.eos?
+              if strscan.scan(/(.)\1{1,127}/m) # a run of <= 128 same characters
+                result << (257 - strscan.matched_size).chr << strscan[1]
+              else # a run of characters until two same characters or length > 128
+                match = strscan.scan(/.{1,128}?(?=(.)\1|\z)|.{128}/m)
+                result << (match.length - 1).chr << match
+              end
+            end
+            Fiber.yield(result)
+          end
+          EOD
+        end
+      end
+
+    end
+
+  end
+end