pnglitch 0.0.1

data/lib/pnglitch/errors.rb

@@ -0,0 +1,37 @@
+module PNGlitch
+
+  class DataSizeError < StandardError
+    def initialize filename, over, expected
+      over_size = digit_format over
+      expected_size = digit_format expected
+      message = <<-EOL.gsub(/^\s*/, '')
+        The size of your data goes over #{over_size}.
+        It should be #{expected_size} actually when it's a normal 
+        formatted PNG file.
+        PNGlitch raised this error to avoid the attack known as
+        "zip bomb". If you are sure that the PNG image is safe, 
+        please set manually your own upper size limit as the variable
+        of PNGlitch#open.
+      EOL
+      message = ["\e[31m", message, "\e[0m"].join if STDOUT.tty?  # color red
+      message = [
+        'Size of the decompressed data is too large - ', 
+        filename, "\n\n", message, "\n"
+      ].join
+      super message
+    end
+
+    def digit_format digit  # :nodoc:
+      digit.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,") + ' bytes'
+    end
+    private :digit_format
+  end
+
+  class FormatError < StandardError
+    def initialize filename
+      m = 'The passed file seems different from a PNG file - ' + filename
+      super m
+    end
+  end
+
+end

data/lib/pnglitch/filter.rb

@@ -0,0 +1,185 @@
+module PNGlitch
+
+  # Filter represents the filtering functions that is defined in PNG spec.
+  #
+  class Filter
+
+    NONE    = 0
+    SUB     = 1
+    UP      = 2
+    AVERAGE = 3
+    PAETH   = 4
+
+    #
+    # Guesses and retuens the filter type as a number.
+    #
+    def self.guess filter_type
+      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]/
+        type = filter_type.to_i
+      else
+        type = ['n', 's', 'u', 'a', 'p'].index(filter_type.to_s[0])
+      end
+      type
+    end
+
+    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
+      @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
+
+    #
+    # Filter with a specified filter type.
+    #
+    def encode data, prev_data = nil
+      @encoder.call data, prev_data
+    end
+
+    #
+    # Reconstruct with a specified filter type.
+    #
+    def decode data, prev_data = nil
+      @decoder.call data, prev_data
+    end
+
+    private
+
+    def encode_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
+      end
+      d
+    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
+        b = prev.getbyte i
+        d.setbyte i, (x - b) & 0xff
+      end
+      d
+    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
+        b = !prev.nil? ? prev.getbyte(i) : 0
+        d.setbyte i, (x - ((a + b) / 2)) & 0xff
+      end
+      d
+    end
+
+    def encode_paeth data, prev # :nodoc:
+      # Filt(x) = Orig(x) - PaethPredictor(Orig(a), Orig(b), Orig(c))
+      #
+      # PaethPredictor(a, b, c)
+      #   p = a + b - c
+      #   pa = abs(p - a)
+      #   pb = abs(p - b)
+      #   pc = abs(p - c)
+      #   if pa <= pb and pa <= pc then Pr = a
+      #   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
+        is_b_exist = !prev.nil?
+        a = is_a_exist ? d.getbyte(i - @pixel_size) : 0
+        b = is_b_exist ? prev.getbyte(i) : 0
+        c = is_a_exist && is_b_exist ? prev.getbyte(i - @pixel_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
+      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
+        is_b_exist = !prev.nil?
+        a = is_a_exist ? d.getbyte(i - @pixel_size) : 0
+        b = is_b_exist ? prev.getbyte(i) : 0
+        c = is_a_exist && is_b_exist ? prev.getbyte(i - @pixel_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
+      end
+      d
+    end
+  end
+end

data/lib/pnglitch/scanline.rb

@@ -0,0 +1,141 @@
+module PNGlitch
+
+  # Scanline is the class that represents a particular PNG image scanline.
+  #
+  # It consists of a filter type and a filtered pixel data.
+  #
+  class Scanline
+
+    attr_reader :index, :filter_type, :prev_filter_type, :filter_codec
+
+    #
+    # Instanciate.
+    #
+    def initialize io, start_at, width, sample_size, at
+      @index = at
+      @io = io
+      @start_at = start_at
+      @data_size = width * sample_size
+      @sample_size = sample_size
+
+      pos = @io.pos
+      @io.pos = @start_at
+      @filter_type = @io.read(1).unpack('C').first
+      @io.pos = pos
+
+      @data = nil
+      @prev_filter_type = nil
+      @filter_codec = { encoder: nil, decoder: nil }
+
+      if block_given?
+        @callback = Proc.new
+      end
+    end
+
+    #
+    # Returns data of the scanline.
+    #
+    def data
+      if @data.nil?
+        pos = @io.pos
+        @io.pos = @start_at + 1
+        @data = @io.read @data_size
+        @io.pos = pos
+      end
+      @data
+    end
+
+    #
+    # Replaces data with given Regexp +pattern+ and +replacement+.
+    #
+    # It is same as <tt>scanline.replace_data(scanline.data.gsub(pattern, replacement))</tt>.
+    # When the data size has changed, the data will be chopped or padded with null string
+    # in original size.
+    #
+    def gsub! pattern, replacement
+      self.replace_data self.data.gsub(pattern, replacement)
+    end
+
+    #
+    # Replace the data with +new_data+.
+    #
+    # When its size has changed, the data will be chopped or padded with null string
+    # in original size.
+    #
+    def replace_data new_data
+      @data = new_data
+      save
+    end
+
+    #
+    # Replace the filter type with +new_filter+, and it will not compute the filters again.
+    #
+    # It means the scanline might get wrong filter type. It will be the efficient way to
+    # break the PNG image.
+    #
+    def graft new_filter
+      @filter_type = new_filter
+      save
+    end
+
+    #
+    # Replace the filter type with +new_filter+, and it will compute the filters again.
+    #
+    # This operation will be a legal way to change filter types.
+    #
+    def change_filter new_filter
+      @prev_filter_type = @filter_type
+      @filter_type = new_filter
+      save
+    end
+
+    #
+    # Registers a custom filter function to encode data.
+    #
+    # With this operation, it will be able to change filter encoding behavior despite 
+    # the specified filter type value. It takes a Proc object or a block.
+    #
+    def register_filter_encoder encoder = nil, &block
+      if !encoder.nil? && encoder.is_a?(Proc)
+        @filter_codec[:encoder] = encoder
+      elsif block_given?
+        @filter_codec[:encoder] = block
+      end
+      save
+    end
+
+    #
+    # Registers a custom filter function to decode data.
+    #
+    # With this operation, it will be able to change filter decoding behavior despite 
+    # 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?
+        @filter_codec[:decoder] = block
+      end
+      save
+    end
+
+
+    #
+    # Save the changes.
+    #
+    def save
+      pos = @io.pos
+      @io.pos = @start_at
+      @io << [@filter_type].pack('C')
+      @io << self.data.slice(0, @data_size).ljust(@data_size, "\0")
+      @io.pos = pos
+      @callback.call(self) unless @callback.nil?
+      self
+    end
+
+    alias data= replace_data
+    alias filter_type= change_filter
+
+  end
+end

data/pnglitch.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pnglitch'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pnglitch"
+  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*/, '')
+    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.
+  EOL
+  spec.homepage      = "https://github.com/ucnv/pnglitch"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/spec/pnglitch_filter_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe PNGlitch::Filter do
+  types = [:none, :sub, :up, :average, :paeth]
+  dir = Pathname(File.dirname(__FILE__)).join('fixtures')
+  tests = {}
+  types.each do |t|
+    data = File.binread(dir.join('filter_' + t.to_s))
+    tests[t] = data.scan %r|[\s\S]{1,#{data.size / 2}}|
+  end
+
+  types.each do |type|
+    context "with #{type} type" do
+      let(:filter) { PNGlitch::Filter.new type, 3 }
+      it 'should encode correctly' do
+        expect(filter.encode(tests[:none][0])).to eq tests[type][0]
+        expect(filter.encode(tests[:none][1], tests[:none][0])).to eq tests[type][1]
+      end
+      it 'should decode correctly' do
+        expect(filter.decode(tests[type][1], tests[:none][0])).to eq tests[:none][1]
+        expect(filter.decode(tests[type][0])).to eq tests[:none][0]
+      end
+    end
+  end
+
+end

data/spec/pnglitch_spec.rb

@@ -0,0 +1,603 @@
+require 'spec_helper'
+
+describe PNGlitch do
+  before :context do
+    @tmpdir = Pathname(File.dirname(__FILE__)).join('fixtures').join('out')
+    FileUtils.mkdir @tmpdir unless File.exist? @tmpdir
+  end
+
+  after :context do
+    FileUtils.remove_entry_secure @tmpdir
+  end
+
+  after :example do
+    FileUtils.rm Dir.glob(@tmpdir.join('*'))
+  end
+
+  let(:infile) { Pathname(File.dirname(__FILE__)).join('fixtures').join('in.png') }
+  let(:outdir) { Pathname(@tmpdir) }
+  let(:outfile) { outdir.join('out.png') }
+
+  describe '.open' do
+    subject(:png) { PNGlitch.open infile }
+    it { is_expected.to be_a PNGlitch::Base }
+
+    it 'can close' do
+      expect { png.close }.not_to raise_error
+      expect {
+        png.compressed_data.read
+      }.to raise_error IOError
+    end
+
+    context 'when it takes a block' do
+      it 'should be closed after the block' do
+        png = nil
+        PNGlitch.open(infile) { |p| png = p }
+        expect {
+          png.compressed_data.read
+        }.to raise_error IOError
+      end
+
+      it 'also can execute with DSL style' do
+        types, h = ()
+        out = outfile
+        expect {
+          PNGlitch.open(infile) do
+            types = filter_types
+            h = height
+            output out
+          end
+        }.not_to raise_error
+        expect(types.size).to eq h
+      end
+
+      it 'should return a value of last call in the block' do
+        e = 0
+        v = PNGlitch.open infile do |p|
+          e = p.height
+          p.height
+        end
+        expect(v).to be == e
+
+        e = 0
+        v = PNGlitch.open infile do
+          e = height
+          height
+        end
+        expect(v).to be == e
+      end
+    end
+
+    context('when decompressed data is unexpected size') do
+      it 'should raise error' do
+        bomb = infile.dirname.join('bomb.png')
+        expect {
+          png = PNGlitch.open bomb
+          png.close
+        }.to raise_error PNGlitch::DataSizeError
+      end
+
+      it 'can avoid the error' do
+        bomb = infile.dirname.join('bomb.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
+      it 'should raise error' do
+        file = infile.dirname.join('filter_none')
+        expect {
+          png = PNGlitch.open file
+          png.close
+        }.to raise_error PNGlitch::FormatError
+      end
+    end
+  end
+
+  describe '.output' do
+    context 'when nothing change' do
+      it 'makes an output to be same as input' do
+        PNGlitch.open infile do |png|
+          png.output outfile
+        end
+        a = open outfile
+        b = open infile
+        expect(a.read.unpack('a*').first).to eq(b.read.unpack('a*').first)
+        a.close
+        b.close
+      end
+    end
+
+    context 'when it generates wrong PNG' do
+      it 'can even read it again (if it has right compression)' do
+        out1 = outfile
+        out2 = outdir.join('out2.png')
+        PNGlitch.open infile do
+          glitch {|d| d.gsub /\d/, '' }
+          output out1
+        end
+        expect {
+          PNGlitch.open outfile do
+            compress
+            output out2
+          end
+        }.not_to raise_error
+      end
+
+      it 'cannot read broken compression' do
+        out1 = outfile
+        out2 = outdir.join('out2.png')
+        PNGlitch.open infile do
+          glitch_after_compress {|d| d.gsub /\d/, 'a' }
+          output out1
+        end
+        expect {
+          PNGlitch.open outfile do
+            compress
+            output out2
+          end
+        }.to raise_error Zlib::DataError
+      end
+    end
+  end
+
+  describe '.compress' do
+    it 'should be lossless' do
+      png = PNGlitch.open infile
+      before = png.filtered_data.read
+      png.compress
+      after = Zlib::Inflate.inflate(png.compressed_data.read)
+      png.close
+      expect(before).to eq after
+    end
+  end
+
+  describe '.glitch' do
+    it 'makes a result that is readable as PNG' do
+      png = PNGlitch.open infile
+      png.glitch do |data|
+        data.gsub /\d/, 'a'
+      end
+      png.output outfile
+      png.close
+      expect {
+        ChunkyPNG::Image.from_file outfile
+      }.not_to raise_error
+    end
+
+    it 'makes a result has an intended size of data' do
+      png1 = PNGlitch.open infile
+      a = png1.filtered_data.size
+      png1.glitch do |data|
+        data.gsub /\d/, 'a'
+      end
+      png1.output outfile
+      png2 = PNGlitch.open outfile
+      b = png2.filtered_data.size
+      png2.close
+      expect(b).to eq a
+
+      png1 = PNGlitch.open infile
+      a = png1.filtered_data.size
+      png1.glitch do |data|
+        data[(data.size / 2), 100] = ''
+        data
+      end
+      png1.output outfile
+      png2 = PNGlitch.open outfile
+      b = png2.filtered_data.size
+      png2.close
+      expect(b).to eq(a - 100)
+    end
+  end
+
+  describe '.glitch_after_compress' do
+    it 'should not fail' do
+      png = PNGlitch.open infile
+      png.glitch_after_compress do |data|
+        data[rand(data.size)] = 'x'
+        data
+      end
+      png.output outfile
+      png.close
+      expect(outfile).to exist
+    end
+
+    context 'when manipulation after glitch_after_compress' do
+      it 'warn' do
+        png = PNGlitch.open infile
+        png.glitch_after_compress do |data|
+          data[rand(data.size)] = 'x'
+          data
+        end
+        expect{
+          png.glitch do |data|
+            data[0] = 'x'
+          end
+        }.to output.to_stderr
+        png.close
+      end
+    end
+  end
+
+  describe '.glitch_as_io' do
+    it 'can generate a same result with glitch method' do
+      out1 = outdir.join 'a.png'
+      out2 = outdir.join 'b.png'
+      pos = []
+      PNGlitch.open infile do |p|
+        p.glitch_as_io do |io|
+          10.times do |i|
+            pos << [rand(io.size), i.to_s]
+          end
+          pos.each do |x|
+            io.pos = x[0]
+            io << x[1]
+          end
+        end
+        p.output out1
+      end
+      PNGlitch.open infile do |p|
+        p.glitch do |data|
+          pos.each do |x|
+            data[x[0]] = x[1]
+          end
+          data
+        end
+        p.output out2
+      end
+
+      a = File.read out1
+      b = File.read out2
+      expect(a.b).to eq b.b
+    end
+  end
+
+  describe '.glitch_after_compress_as_io' do
+    it 'can generate a same result with glitch_after_compress method' do
+      out1 = outdir.join 'a.png'
+      out2 = outdir.join 'b.png'
+      pos = []
+      PNGlitch.open infile do |p|
+        p.glitch_after_compress_as_io do |io|
+          10.times do |i|
+            pos << [rand(io.size), i.to_s]
+          end
+          pos.each do |x|
+            io.pos = x[0]
+            io << x[1]
+          end
+        end
+        p.output out1
+      end
+      PNGlitch.open infile do |p|
+        p.glitch_after_compress do |data|
+          pos.each do |x|
+            data[x[0]] = x[1]
+          end
+          data
+        end
+        p.output out2
+      end
+
+      a = File.read out1
+      b = File.read out2
+      expect(a.b).to eq b.b
+    end
+  end
+
+  describe '.filter_types' do
+    it 'should be same size of image height' do
+      png = PNGlitch.open infile
+      types = png.filter_types
+      height = png.height
+      png.close
+      expect(types.size).to eq height
+    end
+  end
+
+  describe '.each_scanline' do
+    it 'returns Enumerator' do
+      png = PNGlitch.open infile
+      expect(png.each_scanline).to be_a Enumerator
+    end
+
+    it 'can exchange filter types' do
+      png = PNGlitch.open infile
+      png.each_scanline do |line|
+        expect(line).to be_a PNGlitch::Scanline
+        line.graft rand(4)
+      end
+      png.output outfile
+      png.close
+      expect {
+        ChunkyPNG::Image.from_file outfile
+      }.not_to raise_error
+    end
+
+    it 'can rewite scanline data' do
+      png = PNGlitch.open infile
+      png.each_scanline do |line|
+        line.data = line.data.gsub /\d/, 'a'
+      end
+      png.output outfile
+      png.close
+      expect {
+        ChunkyPNG::Image.from_file outfile
+      }.not_to raise_error
+    end
+
+    it 'can change filter types and re-filter' do
+      png = PNGlitch.open infile
+      png.each_scanline do |line|
+        line.change_filter rand(4)
+      end
+      png.output outfile
+      png.close
+      expect {
+        ChunkyPNG::Image.from_file outfile
+      }.not_to raise_error
+
+      if system('which convert > /dev/null')
+        out1 = outdir.join('a.png')
+        out2 = outdir.join('b.png')
+        fx = 4
+        png = PNGlitch.open infile
+        png.each_scanline do |line|
+          line.change_filter fx
+        end
+        png.output out1
+        png.close
+        system('convert -quality %d %s %s' % [fx, infile, out2])
+        png1 = PNGlitch.open out1
+        png2 = PNGlitch.open out2
+        d1 = png1.filtered_data.read
+        d2 = png2.filtered_data.read
+        f1 = png1.filter_types
+        f2 = png2.filter_types
+        png1.close
+        png2.close
+        expect(f1).to eq(f2)
+        expect(d1).to eq(d2)
+      end
+    end
+
+    it 'can apply custom filter method' do
+      lines = []
+      sample_size = nil
+      original_filter = 0
+      PNGlitch.open infile do |png|
+        target = png.scanline_at 100
+        original_filter = target.filter_type
+        lines[1] = target.data
+        sample_size = png.sample_size
+        png.each_scanline do |l|
+          l.change_filter 0
+        end
+        lines[0] = png.scanline_at(99).data
+      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
+          b = !prev.nil? ? prev.getbyte(i - 1) : 0
+          d.setbyte i, (x - ((a + b) / 2)) & 0xff
+        end
+        d
+      end
+      decoded = PNGlitch::Filter.new(original_filter, sample_size).decode(lines[1], lines[0])
+      encoded = enc.call(decoded, lines[0])
+
+      PNGlitch.open infile do |png|
+        png.each_scanline.with_index do |s, i|
+          if i == 100
+            s.register_filter_encoder enc
+          end
+        end
+        png.output outfile
+      end
+      PNGlitch.open outfile do |png|
+        expect(png.scanline_at(100).data).to eq encoded
+      end
+
+      # ==================================
+
+      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
+          b = !prev.nil? ? prev.getbyte(i - 1) : 0
+          d.setbyte i, (x + ((a + b) / 2)) & 0xff
+        end
+        d
+      end
+      decoded = dec.call(lines[1], lines[0])
+      encoded = PNGlitch::Filter.new(original_filter, sample_size).encode(decoded, lines[0])
+
+      PNGlitch.open infile do |png|
+        png.each_scanline.with_index do |s, i|
+          if i == 100
+            s.register_filter_decoder dec
+          end
+        end
+        png.output outfile
+      end
+      PNGlitch.open outfile do |png|
+        expect(png.scanline_at(100).data).to eq encoded
+      end
+
+      # ==================================
+
+      decoded = dec.call(lines[1], lines[0])
+      encoded = enc.call(decoded, lines[0])
+
+      PNGlitch.open infile do |png|
+        png.each_scanline.with_index do |s, i|
+          if i == 100
+            s.register_filter_encoder enc
+            s.register_filter_decoder dec
+          end
+        end
+        png.output outfile
+      end
+      PNGlitch.open outfile do |png|
+        expect(png.scanline_at(100).data).to eq encoded
+      end
+    end
+
+    context 'with wrong sized data' do
+      it 'should raise no errors' do
+        expect {
+          PNGlitch.open infile do |png|
+            pos = png.filtered_data.pos = png.filtered_data.size * 4 / 5
+            png.filtered_data.truncate pos
+            png.each_scanline do |line|
+              line.gsub! /\d/, 'x'
+              line.filter_type = rand(4)
+            end
+            png.output outfile
+          end
+        }.not_to raise_error
+        expect {
+          PNGlitch.open infile do |png|
+            png.filtered_data.pos = png.filtered_data.size * 4 / 5
+            chunk = png.filtered_data.read
+            png.filtered_data.rewind
+            10.times do
+              png.filtered_data << chunk
+            end
+            png.each_scanline do |line|
+              line.gsub! /\d/, 'x'
+              line.filter_type = rand(4)
+            end
+            png.output outfile
+          end
+        }.not_to raise_error
+      end
+    end
+
+    context 'when re-filtering with same filters' do
+      it 'becomes a same result' do
+        png = PNGlitch.open infile
+        png.filtered_data.rewind
+        a = png.filtered_data.read
+        filters = png.filter_types
+        png.each_scanline.with_index do |l, i|
+          l.change_filter PNGlitch::Filter::UP
+        end
+        b = png.filtered_data.read
+        png.each_scanline.with_index do |l, i|
+          l.change_filter filters[i]
+        end
+        png.filtered_data.rewind
+        c = png.filtered_data.read
+        png.output outfile
+        png.close
+        expect(c).to eq(a)
+        expect(b).not_to eq(a)
+      end
+    end
+  end
+
+  describe '.scanline_at' do
+    it 'should reflect the changes to the instance' do
+      PNGlitch.open infile do |png|
+        line = png.scanline_at 100
+        f = line.filter_type
+        line.filter_type = (f + 1) % 5
+        png.output outfile
+      end
+
+      png1 = PNGlitch.open infile
+      line1_100 = png1.scanline_at(100).data
+      line1_95 = png1.scanline_at(95).data
+      png2 = PNGlitch.open outfile
+      line2_100 = png2.scanline_at(100).data
+      line2_95 = png2.scanline_at(95).data
+      png1.close
+      png2.close
+      expect(line2_100).not_to eq(line1_100)
+      expect(line2_95).to eq(line1_95)
+    end
+
+    it 'can apply custom filter method' do
+      lines = []
+      sample_size = nil
+      original_filter = 0
+      PNGlitch.open infile do |png|
+        target = png.scanline_at 100
+        original_filter = target.filter_type
+        lines[1] = target.data
+        sample_size = png.sample_size
+        png.each_scanline do |l|
+          l.change_filter 0
+        end
+        lines[0] = png.scanline_at(99).data
+      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
+          b = !prev.nil? ? prev.getbyte(i - 2) : 0
+          d.setbyte i, (x - ((a + b) / 2)) & 0xff
+        end
+        d
+      end
+      decoded = PNGlitch::Filter.new(original_filter, sample_size).decode(lines[1], lines[0])
+      encoded = enc.call(decoded, lines[0])
+
+      PNGlitch.open infile do |png|
+        l = png.scanline_at 100
+        l.register_filter_encoder enc
+        png.output outfile
+      end
+      PNGlitch.open outfile do |png|
+        expect(png.scanline_at(100).data).to eq encoded
+      end
+    end
+
+    it 'should finalize the instance' do
+      PNGlitch.open infile do
+        lines = scanline_at 1..100
+      end
+      GC.start
+      count = ObjectSpace.each_object(PNGlitch::Scanline).count
+      expect(count).to be < 100
+
+      png = PNGlitch.open infile
+      lines = png.scanline_at 1..100
+      png.close
+      lines = nil
+      GC.start
+      count = ObjectSpace.each_object(PNGlitch::Scanline).count
+      expect(count).to be < 100
+    end
+  end
+
+  describe '.width and .height' do
+    it 'destroy the dimension of the image' do
+      w, h = ()
+      out = outdir.join('t.png') #outfile
+      PNGlitch.open infile do |p|
+        w = p.width
+        h = p.height
+        p.width = w - 10
+        p.height = h + 10
+        p.output out
+      end
+      p = PNGlitch.open out
+      expect(p.width).to equal w - 10
+      expect(p.height).to equal h + 10
+      p.close
+    end
+  end
+
+end