pnglitch 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ef1538aec8847d189241145512fe084c43eca6d
-  data.tar.gz: 010aa625e9d831f09bac45ea3c6ca88ef9f83545
+  metadata.gz: 44d05884a52a43971ee2d6e6f0c0dd79450f7435
+  data.tar.gz: 07e160fdf0a363ac043b94c52e76d9446d7ac66f
 SHA512:
-  metadata.gz: b356a88db6db41d9729dacd936277b2ffeed2af5714f2c3884821e0654c71071bc379d848e6415473ea4aeea1b5a0cf2a83c100b6820cf211003ae3e4c3fcfd1
-  data.tar.gz: ec2db449bb83b8574b2f42a0073540995552c8732a9a453f5c6019382b1bc722a2fe183b1b6ba976290932f7b3935296becbf43467d4d071191fea619f60be85
+  metadata.gz: 73efdd4e1fb833a268a12b35b39359db9225f0c5a1f0c332ae2b35b3559d317210498fd387f5c1f89fe5ad71105bbd77bc77d173faf0db6e974da488720b43f1
+  data.tar.gz: 4f413a38b0e60ac3362ebeea3b0a0a27860fe985084d4dcff6a67e8f446e49536b979b289a6241f3351c3d424f5e471f140a41240d21429f7210e8a247db6a2f

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 rvm:
   - 2.0.0
-  - 2.1.4
+  - 2.2.2

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 ucnv
+Copyright (c) 2014-2015 ucnv
 
 MIT License
 

data/bin/pnglitch

@@ -41,9 +41,7 @@ begin
   infile, outfile = ARGV
   PNGlitch.open infile do |png|
     unless filter.nil?
-      png.each_scanline do |line|
-        line.change_filter filter
-      end
+      png.change_all_filters filter
     end
     png.glitch do |data|
       data.gsub /\d/, 'x'

data/lib/pnglitch/base.rb

@@ -7,7 +7,7 @@ module PNGlitch
   class Base
 
     attr_reader :width, :height, :sample_size, :is_compressed_data_modified
-    attr_accessor :head_data, :tail_data, :compressed_data, :filtered_data
+    attr_accessor :head_data, :tail_data, :compressed_data, :filtered_data, :idat_chunk_size
 
     #
     # Instanciate the class with the passed +file+
@@ -16,8 +16,8 @@ module PNGlitch
       path = Pathname.new file
       @head_data = StringIO.new
       @tail_data = StringIO.new
-      @compressed_data = Tempfile.new 'compressed', :encoding => 'ascii-8bit'
-      @filtered_data = Tempfile.new 'filtered', :encoding => 'ascii-8bit'
+      @compressed_data = Tempfile.new 'compressed', encoding: 'ascii-8bit'
+      @filtered_data = Tempfile.new 'filtered', encoding: 'ascii-8bit'
       @idat_chunk_size = nil
 
       open(path, 'rb') do |io|
@@ -37,6 +37,7 @@ module PNGlitch
             }
             @width = ihdr[:width]
             @height = ihdr[:height]
+            @interlace = ihdr[:interlace_method]
             @sample_size = {0 => 1, 2 => 3, 3 => 1, 4 => 2, 6 => 4}[ihdr[:color_type]]
             io.pos -= 13
           end
@@ -95,10 +96,10 @@ module PNGlitch
     def filter_types
       types = []
       wrap_with_rewind(@filtered_data) do
-        until @filtered_data.eof? do
+        scanline_positions.each do |pos|
+          @filtered_data.pos = pos
           byte = @filtered_data.read 1
           types << byte.unpack('C').first
-          @filtered_data.pos += @width * @sample_size
         end
       end
       types
@@ -156,9 +157,6 @@ module PNGlitch
     #
     # To set a glitched result, return the modified value in the block.
     #
-    # It will raise an error when the data goes over the limit. In such case, please treat
-    # the data as IO through +glitch_after_compress_as_io+ instead.
-    #
     # Once the compressed data is glitched, PNGlitch will warn about modifications to
     # filtered (decompressed) data because this method does not decompress the glitched 
     # compressed data again. It means that calling +glitch+ after +glitch_after_compress+ 
@@ -189,26 +187,32 @@ module PNGlitch
     end
 
     #
-    # (Re-)computes the filtering methods to each scanlines.
-    #
-    # On each scanline, it will compute them and apply the results as the filtered data.
+    # (Re-)computes the filtering methods on each scanline.
     #
     def apply_filters prev_filters = nil, filter_codecs = nil
       prev_filters = filter_types if prev_filters.nil?
       filter_codecs = [] if filter_codecs.nil?
       current_filters = []
       prev = nil
-      line_size = @width * @sample_size
+      line_sizes = []
+      scanline_positions.push(@filtered_data.size).inject do |m, n|
+        line_sizes << n - m - 1
+        n
+      end
       wrap_with_rewind(@filtered_data) do
         # decode all scanlines
         prev_filters.each_with_index do |type, i|
           byte = @filtered_data.read 1
           current_filters << byte.unpack('C').first
+          line_size = line_sizes[i]
           line = @filtered_data.read line_size
           filter = Filter.new type, @sample_size
           if filter_codecs[i] && filter_codecs[i][:decoder]
             filter.decoder = filter_codecs[i][:decoder]
           end
+          if !prev.nil? && @interlace_pass_count.include?(i + 1)  # make sure prev to be nil if interlace pass is changed
+            prev = nil
+          end
           decoded = filter.decode line, prev
           @filtered_data.pos -= line_size
           @filtered_data << decoded
@@ -216,24 +220,29 @@ module PNGlitch
         end
         # encode all
         filter_codecs.reverse!
+        line_sizes.reverse!
         data_amount = @filtered_data.pos # should be eof
+        ref = data_amount
         current_filters.reverse_each.with_index do |type, i|
-          pos = data_amount - ((1 + line_size) * i)
-          posa = pos - line_size
-          @filtered_data.pos = posa
+          line_size = line_sizes[i]
+          ref -= line_size + 1
+          @filtered_data.pos = ref + 1
           line = @filtered_data.read line_size
-          posb = pos - (1 + line_size) - line_size
           prev = nil
-          unless posb < 0
-            @filtered_data.pos = posb
+          if !line_sizes[i + 1].nil?
+            @filtered_data.pos = ref - line_size
             prev = @filtered_data.read line_size
           end
+          # make sure prev to be nil if interlace pass is changed
+          if @interlace_pass_count.include?(current_filters.size - i)
+            prev = nil
+          end
           filter = Filter.new type, @sample_size
           if filter_codecs[i] && filter_codecs[i][:encoder]
             filter.encoder = filter_codecs[i][:encoder]
           end
           encoded = filter.encode line, prev
-          @filtered_data.pos = posa
+          @filtered_data.pos = ref + 1
           @filtered_data << encoded
         end
       end
@@ -269,7 +278,7 @@ module PNGlitch
     #
     # Process each scanlines.
     #
-    # It takes a block with a parameter. The parameter is an instance of
+    # It takes a block with a parameter. The parameter must be an instance of
     # PNGlitch::Scanline and it provides ways to edit the filter type and the data
     # of the scanlines. Normally it iterates the number of the PNG image height.
     #
@@ -280,7 +289,7 @@ module PNGlitch
     #   end
     #
     #   pnglicth.each_scanline do |line|
-    #     line.change_filter 3  # change all filter to 3, data will get re-filtering (it's not be a glitch)
+    #     line.change_filter 3  # change all filter to 3, data will get re-filtering (it won't be a glitch)
     #   end
     #
     #   pnglicth.each_scanline do |line|
@@ -293,7 +302,7 @@ module PNGlitch
     #
     # -----
     #
-    # Please note that +each_scanline+ will apply the filters after the loop. It means
+    # Please note that +each_scanline+ will apply the filters *after* the loop. It means
     # a following example doesn't work as expected.
     #
     #   pnglicth.each_scanline do |line|
@@ -312,32 +321,24 @@ module PNGlitch
     #
     def each_scanline # :yield: scanline
       return enum_for :each_scanline unless block_given?
-
       prev_filters = self.filter_types
       is_refilter_needed = false
       filter_codecs = []
       wrap_with_rewind(@filtered_data) do
-        pos = 0
         at = 0
-        until @filtered_data.eof? do
-          scanline = Scanline.new @filtered_data, pos, @width, @sample_size, at
+        scanline_positions.push(@filtered_data.size).inject do |pos, delimit|
+          scanline = Scanline.new @filtered_data, pos, (delimit - pos - 1), at
           yield scanline
-          unless scanline.prev_filter_type.nil?
-            is_refilter_needed = true
-          else
-            prev_filters[at] = scanline.filter_type  # forget the prev filter when "graft"
-          end
-          filter_codecs << scanline.filter_codec
-          if !filter_codecs.last[:encoder].nil? || !filter_codecs.last[:decoder].nil?
+          if fabricate_scanline(scanline, prev_filters, filter_codecs)
             is_refilter_needed = true
           end
           at += 1
-          pos += @width * @sample_size + 1
-          @filtered_data.pos = pos
+          delimit
         end
       end
       apply_filters(prev_filters, filter_codecs) if is_refilter_needed
       compress
+      self
     end
 
     #
@@ -348,36 +349,61 @@ module PNGlitch
     def scanline_at index_or_range
       base = self
       prev_filters = self.filter_types
-      filter_codecs = nil
+      filter_codecs = Array.new(prev_filters.size)
       scanlines = []
       index_or_range = self.filter_types.size - 1 if index_or_range == -1
       range = index_or_range.is_a?(Range) ? index_or_range : [index_or_range]
-      pos = 0
-      self.filter_types.each.with_index do |filter, at|
+
+      at = 0
+      scanline_positions.push(@filtered_data.size).inject do |pos, delimit|
         if range.include? at
-          s = Scanline.new(@filtered_data, pos, @width, @sample_size, at) do |scanline|
-            is_refilter_needed = false
-            unless scanline.prev_filter_type.nil?
-              is_refilter_needed = true
-            else
-              prev_filters[at] = scanline.filter_type
+          s = Scanline.new(@filtered_data, pos, (delimit - pos - 1), at) do |scanline|
+            if base.fabricate_scanline(scanline, prev_filters, filter_codecs)
+              base.apply_filters(prev_filters, filter_codecs)
             end
-            codec = scanline.filter_codec
-            if !codec[:encoder].nil? || !codec[:decoder].nil?
-              filter_codecs = Array.new(prev_filters.size) if filter_codecs.nil?
-              filter_codecs[at] = codec
-              is_refilter_needed = true
-            end
-            base.apply_filters(prev_filters, filter_codecs) if is_refilter_needed
             base.compress
           end
           scanlines << s
         end
-        pos += @width * @sample_size + 1
+        at += 1
+        delimit
       end
       scanlines.size <= 1 ? scanlines.first : scanlines
     end
 
+    def fabricate_scanline scanline, prev_filters, filter_codecs # :nodoc:
+      at = scanline.index
+      is_refilter_needed = false
+      unless scanline.prev_filter_type.nil?
+        is_refilter_needed = true
+      else
+        prev_filters[at] = scanline.filter_type
+      end
+      codec = filter_codecs[at] = scanline.filter_codec
+      if !codec[:encoder].nil? || !codec[:decoder].nil?
+        is_refilter_needed = true
+      end
+      is_refilter_needed
+    end
+
+    #
+    # Changes filter type values to passed +filter_type+ in all scanlines
+    #
+    def change_all_filters filter_type
+      each_scanline do |line|
+        line.change_filter filter_type
+      end
+      compress
+      self
+    end
+
+    #
+    # Checks if it is interlaced.
+    #
+    def interlaced?
+      @interlace == 1
+    end
+
     #
     # Rewrites the width value.
     #
@@ -394,6 +420,7 @@ module PNGlitch
         end
       end
       @head_data.rewind
+      w
     end
 
     #
@@ -414,27 +441,27 @@ module PNGlitch
         end
       end
       @head_data.rewind
+      h
     end
 
     #
     # Save to the +file+.
     #
     def save file
-      @head_data.rewind
-      @tail_data.rewind
-      @compressed_data.rewind
-      open(file, 'w') do |io|
-        io << @head_data.read
-        chunk_size = @idat_chunk_size || @compressed_data.size
-        type = 'IDAT'
-        until @compressed_data.eof? do
-          data = @compressed_data.read(chunk_size)
-          io << [data.size].pack('N')
-          io << type
-          io << data
-          io << [Zlib.crc32(data, Zlib.crc32(type))].pack('N')
+      wrap_with_rewind(@head_data, @tail_data, @compressed_data) do
+        open(file, 'w') do |io|
+          io << @head_data.read
+          chunk_size = @idat_chunk_size || @compressed_data.size
+          type = 'IDAT'
+          until @compressed_data.eof? do
+            data = @compressed_data.read(chunk_size)
+            io << [data.size].pack('N')
+            io << type
+            io << data
+            io << [Zlib.crc32(data, Zlib.crc32(type))].pack('N')
+          end
+          io << @tail_data.read
         end
-        io << @tail_data.read
       end
       self
     end
@@ -460,6 +487,64 @@ module PNGlitch
       end
     end
 
+    # Calculate positions of scanlines
+    def scanline_positions
+      scanline_pos = [0]
+      amount = @filtered_data.size
+      @interlace_pass_count = []
+      if self.interlaced?
+        # Adam7
+        # Pass 1
+        v = 1 + (@width / 8.0).ceil * @sample_size
+        (@height / 8.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        @interlace_pass_count << scanline_pos.size
+        # Pass 2
+        v = 1 + ((@width - 4) / 8.0).ceil * @sample_size
+        (@height / 8.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        @interlace_pass_count << scanline_pos.size
+        # Pass 3
+        v = 1 + (@width / 4.0).ceil * @sample_size
+        ((@height - 4) / 8.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        @interlace_pass_count << scanline_pos.size
+        # Pass 4
+        v = 1 + ((@width - 2) / 4.0).ceil * @sample_size
+        (@height / 4.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        @interlace_pass_count << scanline_pos.size
+        # Pass 5
+        v = 1 + (@width / 2.0).ceil * @sample_size
+        ((@height - 2) / 4.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        @interlace_pass_count << scanline_pos.size
+        # Pass 6
+        v = 1 + ((@width - 1) / 2.0).ceil * @sample_size
+        (@height / 2.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        @interlace_pass_count << scanline_pos.size
+        # Pass 7
+        v = 1 + @width * @sample_size
+        ((@height - 1) / 2.0).ceil.times do
+          scanline_pos << scanline_pos.last + v
+        end
+        scanline_pos.pop  # no need to keep last position
+      end
+      loop do
+        v = scanline_pos.last + (1 + @width * @sample_size)
+        break if v >= amount
+        scanline_pos << v
+      end
+      scanline_pos
+    end
+
     # Makes warning
     def warn_if_compressed_data_modified # :nodoc:
       if @is_compressed_data_modified
@@ -469,7 +554,7 @@ module PNGlitch
           With this operation, your changes on the compressed data will be reverted.
           Note that a modification to the compressed data does not reflect to the 
           filtered (decompressed) data.
-          It\'s happened around #{trace.last.to_s}
+          It's happened around #{trace.last.to_s}
         EOL
         message = ["\e[33m",  message, "\e[0m"].join if STDOUT.tty?  # color yellow
         warn ["\n", message, "\n"].join

data/lib/pnglitch/filter.rb

@@ -10,6 +10,8 @@ module PNGlitch
     AVERAGE = 3
     PAETH   = 4
 
+    @@types = Filter.constants.sort_by {|c| const_get c }.collect(&:downcase)
+
     #
     # Guesses and retuens the filter type as a number.
     #
@@ -17,10 +19,10 @@ module PNGlitch
       type = nil
       if filter_type.is_a?(Numeric) && filter_type.between?(NONE, PAETH)
         type = filter_type.to_i
-      elsif filter_type.to_s =~ /[0-4]/
+      elsif filter_type.is_a?(String) && filter_type =~ /^[0-4]$/
         type = filter_type.to_i
       else
-        type = ['n', 's', 'u', 'a', 'p'].index(filter_type.to_s[0])
+        type = @@types.collect{|c| c.to_s[0] }.index(filter_type.to_s[0].downcase)
       end
       type
     end
@@ -28,10 +30,10 @@ module PNGlitch
     attr_reader :filter_type
     attr_accessor :encoder, :decoder
 
-    def initialize filter_type, pixel_size
-      @filter_type = Filter.guess filter_type || 0
-      @filter_type_name = [:none, :sub, :up, :average, :paeth][@filter_type]
-      @pixel_size = pixel_size
+    def initialize filter_type, sample_size
+      @filter_type = Filter.guess(filter_type) || 0
+      @filter_type_name = @@types[@filter_type]
+      @sample_size = sample_size
       @encoder = self.method ('encode_%s' % @filter_type_name.to_s).to_sym
       @decoder = self.method ('decode_%s' % @filter_type_name.to_s).to_sym
     end
@@ -40,14 +42,14 @@ module PNGlitch
     # Filter with a specified filter type.
     #
     def encode data, prev_data = nil
-      @encoder.call data, prev_data
+      @encoder.call data.dup, prev_data
     end
 
     #
     # Reconstruct with a specified filter type.
     #
     def decode data, prev_data = nil
-      @decoder.call data, prev_data
+      @decoder.call data.dup, prev_data
     end
 
     private
@@ -56,40 +58,74 @@ module PNGlitch
       data
     end
 
+    def decode_none data, prev # :nodoc:
+      data
+    end
+
     def encode_sub data, prev # :nodoc:
       # Filt(x) = Orig(x) - Orig(a)
-      d = data.dup
-      d.size.times.reverse_each do |i|
-        next if i < @pixel_size
-        x = d.getbyte i
-        a = d.getbyte i - @pixel_size
-        d.setbyte i, (x - a) & 0xff
+      data.size.times.reverse_each do |i|
+        next if i < @sample_size
+        x = data.getbyte i
+        a = data.getbyte i - @sample_size
+        data.setbyte i, (x - a) & 0xff
       end
-      d
+      data
+    end
+
+    def decode_sub data, prev # :nodoc:
+      # Recon(x) = Filt(x) + Recon(a)
+      data.size.times do |i|
+        next if i < @sample_size
+        x = data.getbyte i
+        a = data.getbyte i - @sample_size
+        data.setbyte i, (x + a) & 0xff
+      end
+      data
     end
 
     def encode_up data, prev # :nodoc:
       # Filt(x) = Orig(x) - Orig(b)
       return data if prev.nil?
-      d = data.dup
-      d.size.times.reverse_each do |i|
-        x = d.getbyte i
+      data.size.times.reverse_each do |i|
+        x = data.getbyte i
+        b = prev.getbyte i
+        data.setbyte i, (x - b) & 0xff
+      end
+      data
+    end
+
+    def decode_up data, prev # :nodoc:
+      # Recon(x) = Filt(x) + Recon(b)
+      return data if prev.nil?
+      data.size.times do |i|
+        x = data.getbyte i
         b = prev.getbyte i
-        d.setbyte i, (x - b) & 0xff
+        data.setbyte i, (x + b) & 0xff
       end
-      d
+      data
+    end
+
+    def decode_average data, prev # :nodoc:
+      # Recon(x) = Filt(x) + floor((Recon(a) + Recon(b)) / 2)
+      data.size.times do |i|
+        x = data.getbyte i
+        a = i >= @sample_size ? data.getbyte(i - @sample_size) : 0
+        b = !prev.nil? ? prev.getbyte(i) : 0
+        data.setbyte i, (x + ((a + b) / 2)) & 0xff
+      end
+      data
     end
 
     def encode_average data, prev # :nodoc:
       # Filt(x) = Orig(x) - floor((Orig(a) + Orig(b)) / 2)
-      d = data.dup
-      d.size.times.reverse_each do |i|
-        x = d.getbyte i
-        a = i >= @pixel_size ? d.getbyte(i - @pixel_size) : 0
+      data.size.times.reverse_each do |i|
+        x = data.getbyte i
+        a = i >= @sample_size ? data.getbyte(i - @sample_size) : 0
         b = !prev.nil? ? prev.getbyte(i) : 0
-        d.setbyte i, (x - ((a + b) / 2)) & 0xff
+        data.setbyte i, (x - ((a + b) / 2)) & 0xff
       end
-      d
+      data
     end
 
     def encode_paeth data, prev # :nodoc:
@@ -104,82 +140,40 @@ module PNGlitch
       #   else if pb <= pc then Pr = b
       #   else Pr = c
       #   return Pr
-      d = data.dup
-      d.size.times.reverse_each do |i|
-        x = d.getbyte i
-        is_a_exist = i >= @pixel_size
+      data.size.times.reverse_each do |i|
+        x = data.getbyte i
+        is_a_exist = i >= @sample_size
         is_b_exist = !prev.nil?
-        a = is_a_exist ? d.getbyte(i - @pixel_size) : 0
+        a = is_a_exist ? data.getbyte(i - @sample_size) : 0
         b = is_b_exist ? prev.getbyte(i) : 0
-        c = is_a_exist && is_b_exist ? prev.getbyte(i - @pixel_size) : 0
+        c = is_a_exist && is_b_exist ? prev.getbyte(i - @sample_size) : 0
         p = a + b - c
         pa = (p - a).abs
         pb = (p - b).abs
         pc = (p - c).abs
         pr = pa <= pb && pa <= pc ? a : pb <= pc ? b : c
-        d.setbyte i, (x - pr) & 0xff
+        data.setbyte i, (x - pr) & 0xff
       end
-      d
-    end
-
-    def decode_none data, prev # :nodoc:
       data
     end
 
-    def decode_sub data, prev # :nodoc:
-      # Recon(x) = Filt(x) + Recon(a)
-      d = data.dup
-      d.size.times do |i|
-        next if i < @pixel_size
-        x = d.getbyte i
-        a = d.getbyte i - @pixel_size
-        d.setbyte i, (x + a) & 0xff
-      end
-      d
-    end
-
-    def decode_up data, prev # :nodoc:
-      # Recon(x) = Filt(x) + Recon(b)
-      return data if prev.nil?
-      d = data.dup
-      d.size.times do |i|
-        x = d.getbyte i
-        b = prev.getbyte i
-        d.setbyte i, (x + b) & 0xff
-      end
-      d
-    end
-
-    def decode_average data, prev # :nodoc:
-      # Recon(x) = Filt(x) + floor((Recon(a) + Recon(b)) / 2)
-      d = data.dup
-      d.size.times do |i|
-        x = d.getbyte i
-        a = i >= @pixel_size ? d.getbyte(i - @pixel_size) : 0
-        b = !prev.nil? ? prev.getbyte(i) : 0
-        d.setbyte i, (x + ((a + b) / 2)) & 0xff
-      end
-      d
-    end
-
     def decode_paeth data, prev # :nodoc:
       # Recon(x) = Filt(x) + PaethPredictor(Recon(a), Recon(b), Recon(c))
-      d = data.dup
-      d.size.times do |i|
-        x = d.getbyte i
-        is_a_exist = i >= @pixel_size
+      data.size.times do |i|
+        x = data.getbyte i
+        is_a_exist = i >= @sample_size
         is_b_exist = !prev.nil?
-        a = is_a_exist ? d.getbyte(i - @pixel_size) : 0
+        a = is_a_exist ? data.getbyte(i - @sample_size) : 0
         b = is_b_exist ? prev.getbyte(i) : 0
-        c = is_a_exist && is_b_exist ? prev.getbyte(i - @pixel_size) : 0
+        c = is_a_exist && is_b_exist ? prev.getbyte(i - @sample_size) : 0
         p = a + b - c
         pa = (p - a).abs
         pb = (p - b).abs
         pc = (p - c).abs
         pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c)
-        d.setbyte i, (x + pr) & 0xff
+        data.setbyte i, (x + pr) & 0xff
       end
-      d
+      data
     end
   end
 end

data/lib/pnglitch/scanline.rb

@@ -11,12 +11,11 @@ module PNGlitch
     #
     # Instanciate.
     #
-    def initialize io, start_at, width, sample_size, at
+    def initialize io, start_at, data_size, at
       @index = at
       @io = io
       @start_at = start_at
-      @data_size = width * sample_size
-      @sample_size = sample_size
+      @data_size = data_size
 
       pos = @io.pos
       @io.pos = @start_at
@@ -86,7 +85,7 @@ module PNGlitch
     def change_filter new_filter
       @prev_filter_type = @filter_type
       @filter_type = new_filter
-      save
+      self.save
     end
 
     #
@@ -111,7 +110,6 @@ module PNGlitch
     # the specified filter type value. It takes a Proc object or a block.
     #
     def register_filter_decoder decoder = nil, &block
-      @filter_decoder = decoder
       if !decoder.nil? && decoder.is_a?(Proc)
         @filter_codec[:decoder] = decoder
       elsif block_given?
@@ -120,14 +118,13 @@ module PNGlitch
       save
     end
 
-
     #
     # Save the changes.
     #
     def save
       pos = @io.pos
       @io.pos = @start_at
-      @io << [@filter_type].pack('C')
+      @io << [Filter.guess(@filter_type)].pack('C')
       @io << self.data.slice(0, @data_size).ljust(@data_size, "\0")
       @io.pos = pos
       @callback.call(self) unless @callback.nil?

data/lib/pnglitch.rb

@@ -20,7 +20,7 @@ require 'pnglitch/base'
 # = Usage
 #
 # == Simple glitch
-#
+# 
 #    png = PNGlitch.open '/path/to/your/image.png'
 #    png.glitch do |data|
 #      data.gsub /\d/, 'x'
@@ -39,7 +39,7 @@ require 'pnglitch/base'
 #
 # The +glitch+ method treats the decompressed data into one String instance. It will be
 # very convenient, but please note that it could take a huge size of memory. For example,
-# a normal PNG image in 3264 x 2448 pixels makes over 23 MB of decompressed data.
+# a normal PNG image in 4000 x 3000 pixels makes over 48 MB of decompressed data.
 # In case that the memory usage becomes a concern, it can be written to use IO instead of
 # String.
 #
@@ -64,8 +64,8 @@ require 'pnglitch/base'
 #      png.save '/path/to/broken/image.png'
 #    end
 #
-# Depe:nding a viewer application, the result of the first example using +glitch+ can 
-# detected as unopenable file, because of breaking the filter type bytes (Most applications
+# Depending a viewer application, the result of the first example using +glitch+ can be
+# detected as unopenable, because of breaking the filter type bytes (Most applications
 # will ignore it, but I found the library in java.awt get failed). The operation with
 # +each_scanline+ will be more careful for memory usage and the file itself.
 # It is a polite way, but is slower than the rude +glitch+.
@@ -89,33 +89,34 @@ require 'pnglitch/base'
 #    end
 #
 # Filter is a tiny function for optimizing PNG compression. It can be set different types
-# with each scanline. The five filter types are defined in the spec, are named +None+, +Up+,
-# +Sub+, +Average+ and +Paeth+ (+None+ means no filter, this filter type makes "raw" data).
-# Internally five digits (0-4) become the references.
+# with each scanline. The five filter types are defined in the spec, are named +None+,
+# +Sub+, +Up+, +Average+ and +Paeth+ (+None+ means no filter, this filter type makes "raw"
+# data). Internally five digits (0-4) correspond them.
 #
 # The filter types must be the most important factor behind the representation of glitch
-# results. Each filter has different effect.
+# results. Each filter type has different effect.
 #
-# Generally in PNG file, scanlines has a variety of filter types on each. As in a 
+# Generally in PNG file, scanlines has a variety of filter types on each, as in a
 # convertion by image processing applications (like Photoshop or ImageMagick) they try to
-# apply proper filter types with each scanlines.
+# apply a proper filter type with each scanline.
 #
 # You can check the values like:
 #
 #    puts png.filter_types
 #
-# With +each_scanline+, we can reach the filters particularly.
+# With +each_scanline+, we can reach the filter types particularly.
 #
 #    png.each_scanline do |scanline|
+#      puts scanline.filter_type
 #      scanline.change_filter 3
 #    end
 #
 # The example above puts all filter types in 3 (type +Average+). +change_filter+ will
 # apply new filter type values correctly. It computes filters and makes the PNG well
-# formatted, and any glitch won't get happened. It also means the output image would have
-# completely looks the same as the input one.
+# formatted, and any glitch won't get happened. It also means the output image should
+# completely look the same as the input one.
 #
-# However glitches might reveal the difference of filter types.
+# However glitches will reveal the difference of the filter types.
 #
 #    PNGlitch.open(infile) do |png|
 #      png.each_scanline do |scanline|
@@ -139,10 +140,10 @@ require 'pnglitch/base'
 #
 # With the results of the example above, obviously we can recognize the filter types make
 # a big difference. The filter is distinct and interesting thing in PNG glitching.
-# To put all filter type in a same value before glitching, we could see the signature
-# taste of each filter type. (Note that +change_filter+ will be a little bit slow, image
-# processing libraries like ImageMagick also have the option to put all filter type in
-# same ones and they will process faster.)
+# To put all filter type in a same value before glitching, we would see the signature
+# taste of each filter type. (Note that +change_filter+ may be a little bit slow, image
+# processing libraries like ImageMagick also have an option to put all filter type in
+# same ones and they may process faster.)
 #
 # This library provides a simple method to change the filter type so that generating all
 # possible effects in PNG glitch.
@@ -159,13 +160,12 @@ require 'pnglitch/base'
 #
 #    png.each_scanline do |scanline|
 #      scanline.register_filter_encoder do |data, prev|
-#        d = data.dup
-#        d.size.times.reverse_each do |i|
-#          x = d.getbyte(i)
+#        data.size.times.reverse_each do |i|
+#          x = data.getbyte(i)
 #          v = prev ? prev.getbyte((i - 5).abs) : 0
-#          d.setbyte(i, (x - v) & 0xff)
+#          data.setbyte(i, (x - v) & 0xff)
 #        end
-#        d
+#        data
 #      end
 #    end
 #
@@ -178,7 +178,7 @@ require 'pnglitch/base'
 #    +----------+    +---------------+    +-----------------+    +----------------+
 #
 # It shows that there are two states between raw data and a result file, and it means there
-# are  two states possible to glitch. This library provides to choose of the state to glitch.
+# are two states possible to glitch. This library provides to choose of the state to glitch.
 #
 # All examples cited thus far are operations to "filtered data". On the other hand, PNGlitch
 # can touch the "compressed data" through +glitch_after_compress+ method:
@@ -189,10 +189,10 @@ require 'pnglitch/base'
 #     end
 #
 # Glitch against the compressed data makes slightly different pictures from other results.
-# But sometimes this scratch would break the compression and make the file unopenable.
+# But sometimes this scratch could break the compression and make the file unopenable.
 #
 module PNGlitch
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 
   class << self
 
@@ -222,10 +222,11 @@ module PNGlitch
     # the amount of pixels).
     # To avoid the attack known as "zip bomb", PNGlitch will throw an error when
     # decompressed data goes over twice the expected size. If it's sure that the passed
-    # file is safe, the upper limit of decompressed data size can be set in +open+'s option.
+    # file is safe, the upper limit of decompressed data size can be set in +open+'s option
+    # in bytes.
     # Like:
     #
-    #   PNGlitch.open(infile, limit_of_decompressed_data_size: 1 * 1024 ** 3)
+    #   PNGlitch.open(infile, limit_of_decompressed_data_size: 1024 ** 3)
     #
     def open file, options = {}
       base = Base.new file, options[:limit_of_decompressed_data_size]

data/pnglitch.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = PNGlitch::VERSION
   spec.authors       = ["ucnv"]
   spec.email         = ["ucnvvv@gmail.com"]
-  spec.summary       = %q{A Ruby library to glitch PNG images.}
-  spec.description   = <<-EOL.gsub(/^\s*/, '')
+  spec.description   = %q{A Ruby library to glitch PNG images.}
+  spec.summary       = <<-EOL.gsub(/^\s*/, '')
     PNGlitch is a Ruby library to destroy your PNG images.
     With normal data-bending technique, a glitch against PNG will easily fail
     because of the checksum function. We provide a fail-proof destruction for it.

data/spec/pnglitch_filter_spec.rb

@@ -23,4 +23,10 @@ describe PNGlitch::Filter do
     end
   end
 
+  describe '.guess' do
+    it 'should detect wrong value as nil' do
+      v = PNGlitch::Filter.guess 34
+      expect(v).to be_nil
+    end
+  end
 end

data/spec/pnglitch_spec.rb

@@ -49,6 +49,7 @@ describe PNGlitch do
           end
         }.not_to raise_error
         expect(types.size).to eq h
+        expect(outfile).to exist
       end
 
       it 'should return a value of last call in the block' do
@@ -68,9 +69,17 @@ describe PNGlitch do
       end
     end
 
-    context('when decompressed data is unexpected size') do
-      it 'should raise error' do
-        bomb = infile.dirname.join('bomb.png')
+    context 'when decompressed data is unexpected size' do
+      it 'should not raise error for too small size' do
+        bomb = infile.dirname.join('ina.png')
+        expect {
+          png = PNGlitch.open bomb
+          png.close
+        }.to_not raise_error
+      end
+
+      it 'should raise error for too large size' do
+        bomb = infile.dirname.join('inb.png')
         expect {
           png = PNGlitch.open bomb
           png.close
@@ -78,15 +87,16 @@ describe PNGlitch do
       end
 
       it 'can avoid the error' do
-        bomb = infile.dirname.join('bomb.png')
+        bomb = infile.dirname.join('inb.png')
         expect {
           png = PNGlitch.open bomb, limit_of_decompressed_data_size: 100 * 1024 ** 2
           png.close
         }.not_to raise_error
       end
+
     end
 
-    context('when it is not PNG file') do
+    context 'when it is not PNG file' do
       it 'should raise error' do
         file = infile.dirname.join('filter_none')
         expect {
@@ -95,6 +105,20 @@ describe PNGlitch do
         }.to raise_error PNGlitch::FormatError
       end
     end
+
+    context 'with interlaced image' do
+      it 'should check it' do
+        a = PNGlitch.open infile do |p|
+          p.interlaced?
+        end
+        interlace = infile.dirname.join('inc.png')
+        b = PNGlitch.open interlace do |p|
+          p.interlaced?
+        end
+        expect(a).to be false
+        expect(b).to be true
+      end
+    end
   end
 
   describe '.output' do
@@ -155,6 +179,19 @@ describe PNGlitch do
     end
   end
 
+  describe '.apply_filters' do
+    it 'should ignore wrong filter types' do
+      PNGlitch.open infile do |p|
+        io = p.filtered_data
+        io.rewind
+        io << [100].pack('C')
+        expect {
+          p.apply_filters
+        }.not_to raise_error
+      end
+    end
+  end
+
   describe '.glitch' do
     it 'makes a result that is readable as PNG' do
       png = PNGlitch.open infile
@@ -290,6 +327,15 @@ describe PNGlitch do
   end
 
   describe '.filter_types' do
+    it 'should be in range between 0 and 4' do
+      png = PNGlitch.open infile
+      types = png.filter_types
+      png.close
+      types.each do |t|
+        expect(t).to be_between(0, 4)
+      end
+    end
+
     it 'should be same size of image height' do
       png = PNGlitch.open infile
       types = png.filter_types
@@ -297,6 +343,19 @@ describe PNGlitch do
       png.close
       expect(types.size).to eq height
     end
+
+    context 'with interlaced PNG' do
+      it 'should be in range between 0 and 4' do
+        png = PNGlitch.open infile.dirname.join('inc.png')
+        types = png.filter_types
+        png.close
+        types.each do |t|
+          expect(t).to be_between(0, 4)
+        end
+      end
+
+    end
+
   end
 
   describe '.each_scanline' do
@@ -365,6 +424,36 @@ describe PNGlitch do
       end
     end
 
+    it 'can change filter type with the name' do
+      t1 = PNGlitch.open infile do |p|
+        p.each_scanline do |l|
+          l.change_filter PNGlitch::Filter::PAETH
+        end
+        p.filter_types
+      end
+      t2 = PNGlitch.open infile do |p|
+        p.each_scanline do |l|
+          l.change_filter :paeth
+        end
+        p.filter_types
+      end
+      t3 = PNGlitch.open infile do |p|
+        p.each_scanline do |l|
+          l.change_filter :sub
+        end
+        p.filter_types
+      end
+      t4 = PNGlitch.open infile do |p|
+        p.each_scanline do |l|
+          l.graft 'Paeth'
+        end
+        p.filter_types
+      end
+      expect(t2).to be == t1
+      expect(t3).not_to be == t1
+      expect(t4).to be == t1
+    end
+
     it 'can apply custom filter method' do
       lines = []
       sample_size = nil
@@ -381,17 +470,16 @@ describe PNGlitch do
       end
 
       enc = lambda do |data, prev|
-        d = data.dup
-        d.size.times.reverse_each do |i|
-          x = d.getbyte i
-          a = i >= sample_size ? d.getbyte(i - sample_size - 1) : 0
+        data.size.times.reverse_each do |i|
+          x = data.getbyte i
+          a = i >= sample_size ? data.getbyte(i - sample_size - 1) : 0
           b = !prev.nil? ? prev.getbyte(i - 1) : 0
-          d.setbyte i, (x - ((a + b) / 2)) & 0xff
+          data.setbyte i, (x - ((a + b) / 2)) & 0xff
         end
-        d
+        data
       end
       decoded = PNGlitch::Filter.new(original_filter, sample_size).decode(lines[1], lines[0])
-      encoded = enc.call(decoded, lines[0])
+      encoded = enc.call(decoded.dup, lines[0])
 
       PNGlitch.open infile do |png|
         png.each_scanline.with_index do |s, i|
@@ -408,16 +496,15 @@ describe PNGlitch do
       # ==================================
 
       dec = lambda do |data, prev|
-        d = data.dup
-        d.size.times do |i|
-          x = d.getbyte i
-          a = i >= sample_size ? d.getbyte(i - sample_size - 2) : 0
+        data.size.times do |i|
+          x = data.getbyte i
+          a = i >= sample_size ? data.getbyte(i - sample_size - 2) : 0
           b = !prev.nil? ? prev.getbyte(i - 1) : 0
-          d.setbyte i, (x + ((a + b) / 2)) & 0xff
+          data.setbyte i, (x + ((a + b) / 2)) & 0xff
         end
-        d
+        data
       end
-      decoded = dec.call(lines[1], lines[0])
+      decoded = dec.call(lines[1].dup, lines[0])
       encoded = PNGlitch::Filter.new(original_filter, sample_size).encode(decoded, lines[0])
 
       PNGlitch.open infile do |png|
@@ -434,8 +521,8 @@ describe PNGlitch do
 
       # ==================================
 
-      decoded = dec.call(lines[1], lines[0])
-      encoded = enc.call(decoded, lines[0])
+      decoded = dec.call(lines[1].dup, lines[0])
+      encoded = enc.call(decoded.dup, lines[0])
 
       PNGlitch.open infile do |png|
         png.each_scanline.with_index do |s, i|
@@ -503,6 +590,22 @@ describe PNGlitch do
         expect(b).not_to eq(a)
       end
     end
+
+    context 'with an interlaced image' do
+      it 'can recognize correct filter types' do
+        img = infile.dirname.join('inc.png')
+        PNGlitch.open img do |p|
+          p.each_scanline do |line|
+            expect(line.filter_type).to be_between(0, 4)
+          end
+          p.change_all_filters 4
+          p.each_scanline do |line|
+            expect(line.filter_type).to be == 4
+          end
+          p.save outfile.dirname.join('i.png')
+        end
+      end
+    end
   end
 
   describe '.scanline_at' do
@@ -542,17 +645,16 @@ describe PNGlitch do
       end
 
       enc = lambda do |data, prev|
-        d = data.dup
-        d.size.times.reverse_each do |i|
-          x = d.getbyte i
-          a = i >= sample_size ? d.getbyte(i - sample_size - 1) : 0
+        data.size.times.reverse_each do |i|
+          x = data.getbyte i
+          a = i >= sample_size ? data.getbyte(i - sample_size - 1) : 0
           b = !prev.nil? ? prev.getbyte(i - 2) : 0
-          d.setbyte i, (x - ((a + b) / 2)) & 0xff
+          data.setbyte i, (x - ((a + b) / 2)) & 0xff
         end
-        d
+        data
       end
       decoded = PNGlitch::Filter.new(original_filter, sample_size).decode(lines[1], lines[0])
-      encoded = enc.call(decoded, lines[0])
+      encoded = enc.call(decoded.dup, lines[0])
 
       PNGlitch.open infile do |png|
         l = png.scanline_at 100
@@ -582,10 +684,27 @@ describe PNGlitch do
     end
   end
 
+  describe '.change_all_filters' do
+    it 'can change filter types with single method' do
+      v = rand(4)
+      PNGlitch.open infile do |p|
+        p.change_all_filters v
+        p.save outfile
+      end
+      PNGlitch.open outfile do |p|
+        p.each_scanline do |l|
+          expect(l.filter_type).to be == v
+        end
+      end
+
+
+    end
+  end
+
   describe '.width and .height' do
     it 'destroy the dimension of the image' do
       w, h = ()
-      out = outdir.join('t.png') #outfile
+      out = outfile
       PNGlitch.open infile do |p|
         w = p.width
         h = p.height
@@ -600,4 +719,36 @@ describe PNGlitch do
     end
   end
 
+  describe '.idat_chunk_size' do
+    it 'should be controllable' do
+      amount = nil
+      out1 = outdir.join 'a.png'
+      out2 = outdir.join 'b.png'
+      PNGlitch.open infile do |p|
+        amount = p.compressed_data.size
+        p.idat_chunk_size = 1024
+        p.output out1
+      end
+      PNGlitch.open out1 do |p|
+        expect(p.idat_chunk_size).to be == 1024
+      end
+      idat_size = open(out1, 'rb') do |f|
+        f.read.scan(/IDAT/).size
+      end
+      expect(idat_size).to be == (amount.to_f / 1024).ceil
+
+      PNGlitch.open infile do |p|
+        p.idat_chunk_size = nil
+        p.output out2
+      end
+      PNGlitch.open out2 do |p|
+        expect(p.idat_chunk_size).to be nil
+      end
+      idat_size = open(out2, 'rb') do |f|
+        f.read.scan(/IDAT/).size
+      end
+      expect(idat_size).to be == 1
+    end
+  end
+
 end

metadata

@@ -1,62 +1,58 @@
 --- !ruby/object:Gem::Specification
 name: pnglitch
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - ucnv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2015-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |
-  PNGlitch is a Ruby library to destroy your PNG images.
-  With normal data-bending technique, a glitch against PNG will easily fail
-  because of the checksum function. We provide a fail-proof destruction for it.
-  Using this library you will see beautiful and various PNG artifacts.
+description: A Ruby library to glitch PNG images.
 email:
 - ucnvvv@gmail.com
 executables:
@@ -64,9 +60,9 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -78,13 +74,15 @@ files:
 - lib/pnglitch/filter.rb
 - lib/pnglitch/scanline.rb
 - pnglitch.gemspec
-- spec/fixtures/bomb.png
 - spec/fixtures/filter_average
 - spec/fixtures/filter_none
 - spec/fixtures/filter_paeth
 - spec/fixtures/filter_sub
 - spec/fixtures/filter_up
 - spec/fixtures/in.png
+- spec/fixtures/ina.png
+- spec/fixtures/inb.png
+- spec/fixtures/inc.png
 - spec/pnglitch_filter_spec.rb
 - spec/pnglitch_spec.rb
 - spec/spec_helper.rb
@@ -98,28 +96,33 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: A Ruby library to glitch PNG images.
+summary: PNGlitch is a Ruby library to destroy your PNG images. With normal data-bending
+  technique, a glitch against PNG will easily fail because of the checksum function.
+  We provide a fail-proof destruction for it. Using this library you will see beautiful
+  and various PNG artifacts.
 test_files:
-- spec/fixtures/bomb.png
 - spec/fixtures/filter_average
 - spec/fixtures/filter_none
 - spec/fixtures/filter_paeth
 - spec/fixtures/filter_sub
 - spec/fixtures/filter_up
 - spec/fixtures/in.png
+- spec/fixtures/ina.png
+- spec/fixtures/inb.png
+- spec/fixtures/inc.png
 - spec/pnglitch_filter_spec.rb
 - spec/pnglitch_spec.rb
 - spec/spec_helper.rb