pnglitch 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ef1538aec8847d189241145512fe084c43eca6d
+  data.tar.gz: 010aa625e9d831f09bac45ea3c6ca88ef9f83545
+SHA512:
+  metadata.gz: b356a88db6db41d9729dacd936277b2ffeed2af5714f2c3884821e0654c71071bc379d848e6415473ea4aeea1b5a0cf2a83c100b6820cf211003ae3e4c3fcfd1
+  data.tar.gz: ec2db449bb83b8574b2f42a0073540995552c8732a9a453f5c6019382b1bc722a2fe183b1b6ba976290932f7b3935296becbf43467d4d071191fea619f60be85

data/.gitignore

@@ -0,0 +1,20 @@
+*.sw?
+.DS_Store
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Guardfile

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

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

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'chunky_png'
+end
+
+group :doc do
+  gem 'yard'
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 ucnv
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# PNGlitch
+
+[![Build Status](https://travis-ci.org/ucnv/pnglitch.svg?branch=master)](https://travis-ci.org/ucnv/pnglitch)
+
+
+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.
+
+## Usage
+
+```ruby
+    PNGlitch.open('/path/to/your/image.png') do |p|
+      p.glitch do |data|
+        data.gsub /\d/, 'x'
+      end
+      p.save '/path/to/broken/image.png'
+    end
+```
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pnglitch'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pnglitch
+
+## Contributing
+
+1. Fork it ( http://github.com/ucnv/pnglitch/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+end
+

data/bin/pnglitch

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'pnglitch'
+
+program_name = File.basename($0)
+usage = <<USAGE
+Usage:
+  #{program_name} <infile> [--filter=<n>] <outfile>
+
+Options:
+  -f, --filter=<n>  Fix all filter types as passed value before glitching.
+                    A number (0..4) or a type name (none|sub|up|average|paeth).
+  --version         Show version.
+  -h, --help        Show this screen.
+
+USAGE
+
+filter = nil
+
+ARGV.options do |o|
+  o.program_name = program_name
+  o.on('-f', '--filter=N', String)  do |n|
+    filter = PNGlitch::Filter.guess n
+  end
+
+  o.on_tail('--version') do
+    puts PNGlitch::VERSION
+    exit
+  end
+
+  o.on_tail('-h', '--help') do
+    puts usage
+    exit
+  end
+
+  o.parse!
+end
+
+begin
+  raise 'Wrong options' if ARGV.size < 2
+  infile, outfile = ARGV
+  PNGlitch.open infile do |png|
+    unless filter.nil?
+      png.each_scanline do |line|
+        line.change_filter filter
+      end
+    end
+    png.glitch do |data|
+      data.gsub /\d/, 'x'
+    end
+    png.save outfile
+  end
+rescue => e
+  puts e.message
+  puts
+  puts usage
+end

data/lib/pnglitch.rb

@@ -0,0 +1,249 @@
+require 'pathname'
+require 'stringio'
+require 'tempfile'
+require 'zlib'
+require 'pnglitch/errors'
+require 'pnglitch/filter'
+require 'pnglitch/scanline'
+require 'pnglitch/base'
+
+# PNGlitch is a Ruby library to manipulate PNG images, solely for the purpose to "glitch" them.
+#
+# Since PNG has CRC checksum in the spec, the viewer applications always detect it
+# and reject to display broken PNGs. It is why a simple glitching with a text or binary editor
+# gets easily failed, differently from images like JPEG.
+# This library provides the fix to take the total failure of glitching out, and to keep 
+# your PNG undead.
+#
+# Also it provides options to generate varied glitch results.
+#
+# = Usage
+#
+# == Simple glitch
+#
+#    png = PNGlitch.open '/path/to/your/image.png'
+#    png.glitch do |data|
+#      data.gsub /\d/, 'x'
+#    end
+#    png.save '/path/to/broken/image.png'
+#    png.close
+#
+# The code above can be written with a block like below:
+#
+#    PNGlitch.open('/path/to/your/image.png') do |png|
+#      png.glitch do |data|
+#        data.gsub /\d/, 'x'
+#      end
+#      png.save '/path/to/broken/image.png'
+#    end
+#
+# 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.
+# In case that the memory usage becomes a concern, it can be written to use IO instead of
+# String.
+#
+#    PNGlitch.open('/path/to/your/image.png') do |png|
+#      buf = 2 ** 18
+#      png.glitch_as_io do |io|
+#        until io.eof? do
+#          d = io.read(buf)
+#          io.pos -= d.size
+#          io.print(d.gsub(/\d/, 'x'))
+#        end
+#      end
+#      png.save '/path/to/broken/image.png'
+#    end
+#
+# PNGlitch also provides to manipulate with each scanline.
+#
+#    PNGlitch.open('/path/to/your/image.png') do |png|
+#      png.each_scanline do |scanline|
+#        scanline.gsub! /\d/, 'x'
+#      end
+#      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
+# 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+.
+#
+#
+# == Scanlines and filter types
+#
+# Scanline consists of data of pixels and a filter type value.
+#
+# To change the data of pixels, use +Scanline#replace_data+.
+#
+#    png.each_scanline do |scanline|
+#      data = scanline.data
+#      scanline.replace_data(data.gsub(/\d/, 'x'))
+#    end
+#
+# Or +Scanline#gsub!+ works like +String#gsub!+
+#
+#    png.each_scanline do |scanline|
+#      scanline.gsub! /\d/, 'x'
+#    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.
+#
+# The filter types must be the most important factor behind the representation of glitch
+# results. Each filter has different effect.
+#
+# 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.
+#
+# You can check the values like:
+#
+#    puts png.filter_types
+#
+# With +each_scanline+, we can reach the filters particularly.
+#
+#    png.each_scanline do |scanline|
+#      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.
+#
+# However glitches might reveal the difference of filter types.
+#
+#    PNGlitch.open(infile) do |png|
+#      png.each_scanline do |scanline|
+#        scanline.change_filter 3
+#      end
+#      png.glitch do |data|
+#        data.gsub /\d/, 'x'
+#      end
+#      png.save outfile1
+#    end
+#    
+#    PNGlitch.open(infile) do |png|
+#      png.each_scanline do |scanline|
+#        scanline.change_filter 4
+#      end
+#      png.glitch do |data|
+#        data.gsub /\d/, 'x'
+#      end
+#      png.save outfile2
+#    end
+#
+# 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.)
+#
+# This library provides a simple method to change the filter type so that generating all
+# possible effects in PNG glitch.
+#
+# PNGlitch also provides to make the filter types wrong. Following example swaps the
+# filter types but remains data unchanged. It means to put a wrong filter type applied.
+#
+#    png.each_scanline do |scanline|
+#      scanline.graft rand(4)
+#    end
+#
+# Additionally, it is possible to break the filter function. Registering a (wrong) filter
+# function like below, we can make glitches with an algorithmic touch.
+#
+#    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)
+#          v = prev ? prev.getbyte((i - 5).abs) : 0
+#          d.setbyte(i, (x - v) & 0xff)
+#        end
+#        d
+#      end
+#    end
+#
+# == States
+#
+# Put very simply, the encoding process of PNG is like:
+#
+#    +----------+    +---------------+    +-----------------+    +----------------+
+#    | Raw data | -> | Filtered data | -> | Compressed data | -> | Formatted file |
+#    +----------+    +---------------+    +-----------------+    +----------------+
+#
+# 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.
+#
+# 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:
+#
+#     png.glitch_after_compress do |data|
+#       data[rand(data.size)] = 'x'
+#       data
+#     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.
+#
+module PNGlitch
+  VERSION = '0.0.1'
+
+  class << self
+
+    #
+    # Opens a passed PNG file and returns Base instance.
+    #
+    #   png = PNGltch.open infile
+    #   png.glitch do |data|
+    #     data.gsub /\d/, 'x'
+    #   end
+    #   png.close
+    #
+    # +open+ will generate Tempfile internally and you should make sure to call +close+
+    # method on the end of operations for removing tempfiles.
+    #
+    # Same as File.open, it can take a block and will automatically close.
+    # An example bellow is same as above one.
+    #
+    #   PNGlitch.open(infile) do |png|
+    #     png.glitch do |data|
+    #       data.gsub /\d/, 'x'
+    #     end
+    #   end
+    #
+    # Under normal conditions, the size of the decompressed data of PNG image becomes
+    # <tt>(1 + image_width * sample_size) * image_height</tt> in bytes (mostly over 4 times
+    # 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.
+    # Like:
+    #
+    #   PNGlitch.open(infile, limit_of_decompressed_data_size: 1 * 1024 ** 3)
+    #
+    def open file, options = {}
+      base = Base.new file, options[:limit_of_decompressed_data_size]
+      if block_given?
+        begin
+          block = Proc.new
+          if block.arity == 0
+            base.instance_eval &block
+          else
+            block.call base
+          end
+        ensure
+          base.close
+        end
+      else
+        base
+      end
+    end
+  end
+
+end

data/lib/pnglitch/base.rb

@@ -0,0 +1,479 @@
+module PNGlitch
+
+  # Base is the class that represents the interface for PNGlitch functions.
+  #
+  # It will be initialized through PNGlitch#open and be a mainly used instance.
+  #
+  class Base
+
+    attr_reader :width, :height, :sample_size, :is_compressed_data_modified
+    attr_accessor :head_data, :tail_data, :compressed_data, :filtered_data
+
+    #
+    # Instanciate the class with the passed +file+
+    #
+    def initialize file, limit_of_decompressed_data_size = nil
+      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'
+      @idat_chunk_size = nil
+
+      open(path, 'rb') do |io|
+        idat_sizes = []
+        @head_data << io.read(8) # signature
+        while bytes = io.read(8)
+          length, type = bytes.unpack 'Na*'
+          if type == 'IHDR'
+            ihdr = {
+              width:              io.read(4).unpack('N').first,
+              height:             io.read(4).unpack('N').first,
+              bit_depth:          io.read(1).unpack('C').first,
+              color_type:         io.read(1).unpack('C').first,
+              compression_method: io.read(1).unpack('C').first,
+              filter_method:      io.read(1).unpack('C').first,
+              interlace_method:   io.read(1).unpack('C').first,
+            }
+            @width = ihdr[:width]
+            @height = ihdr[:height]
+            @sample_size = {0 => 1, 2 => 3, 3 => 1, 4 => 2, 6 => 4}[ihdr[:color_type]]
+            io.pos -= 13
+          end
+          if type == 'IDAT'
+            @compressed_data << io.read(length)
+            idat_sizes << length
+            io.pos += 4 # crc
+          else
+            target_io = @compressed_data.pos == 0 ? @head_data : @tail_data
+            target_io << bytes
+            target_io << io.read(length + 4)
+          end
+        end
+        @idat_chunk_size = idat_sizes.first if idat_sizes.size > 1
+      end
+      if @compressed_data.size == 0
+        raise FormatError.new path.to_s
+      end
+      @head_data.rewind
+      @tail_data.rewind
+      @compressed_data.rewind
+      decompressed_size = 0
+      expected_size = (1 + @width * @sample_size) * @height
+      expected_size = limit_of_decompressed_data_size unless limit_of_decompressed_data_size.nil?
+      z = Zlib::Inflate.new
+      z.inflate(@compressed_data.read) do |chunk|
+        decompressed_size += chunk.size
+        # raise error when the data size goes over 2 times the usually expected size
+        if decompressed_size > expected_size * 2
+          z.close
+          self.close
+          raise DataSizeError.new path.to_s, decompressed_size, expected_size
+        end
+        @filtered_data << chunk
+      end
+      z.close
+      @compressed_data.rewind
+      @filtered_data.rewind
+      @is_compressed_data_modified = false
+    end
+
+    #
+    # Explicit file close.
+    #
+    # It will close tempfiles that used internally.
+    #
+    def close
+      @compressed_data.close
+      @filtered_data.close
+      self
+    end
+
+    #
+    # Returns an array of each scanline's filter type value.
+    #
+    def filter_types
+      types = []
+      wrap_with_rewind(@filtered_data) do
+        until @filtered_data.eof? do
+          byte = @filtered_data.read 1
+          types << byte.unpack('C').first
+          @filtered_data.pos += @width * @sample_size
+        end
+      end
+      types
+    end
+
+    #
+    # Manipulates the filtered (decompressed) data as String.
+    #
+    # To set a glitched result, return the modified value in the block.
+    #
+    # Example:
+    #
+    #   p = PNGlitch.open 'path/to/your/image.png'
+    #   p.glitch do |data|
+    #     data.gsub /\d/, 'x'
+    #   end
+    #   p.save 'path/to/broken/image.png'
+    #   p.close
+    #
+    # This operation has the potential to damage filter type bytes. The damage will be a cause of
+    # glitching but some viewer applications might deny to process those results.
+    # To be polite to the filter types, use +each_scanline+ instead.
+    #
+    # Since this method sets the decompressed data into String, it may use a massive amount of 
+    # memory. To decrease the memory usage, treat the data as IO through +glitch_as_io+ instead.
+    #
+    def glitch &block   # :yield: data
+      warn_if_compressed_data_modified
+
+      wrap_with_rewind(@filtered_data) do
+        result = yield @filtered_data.read
+        @filtered_data.rewind
+        @filtered_data << result
+        truncate_io @filtered_data
+      end
+      compress
+      self
+    end
+
+    #
+    # Manipulates the filtered (decompressed) data as IO.
+    #
+    def glitch_as_io &block # :yield: data
+      warn_if_compressed_data_modified
+
+      wrap_with_rewind(@filtered_data) do
+        yield @filtered_data
+      end
+      compress
+      self
+    end
+
+    #
+    # Manipulates the after-compressed data as String.
+    #
+    # 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+ 
+    # will make the result overwritten and forgotten.
+    #
+    # This operation will often destroy PNG image completely.
+    #
+    def glitch_after_compress &block   # :yield: data
+      wrap_with_rewind(@compressed_data) do
+        result = yield @compressed_data.read
+        @compressed_data.rewind
+        @compressed_data << result
+        truncate_io @compressed_data
+      end
+      @is_compressed_data_modified = true
+      self
+    end
+
+    #
+    # Manipulates the after-compressed data as IO.
+    #
+    def glitch_after_compress_as_io &block # :yield: data
+      wrap_with_rewind(@compressed_data) do
+        yield @compressed_data
+      end
+      @is_compressed_data_modified = true
+      self
+    end
+
+    #
+    # (Re-)computes the filtering methods to each scanlines.
+    #
+    # On each scanline, it will compute them and apply the results as the filtered data.
+    #
+    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
+      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 = @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
+          decoded = filter.decode line, prev
+          @filtered_data.pos -= line_size
+          @filtered_data << decoded
+          prev = decoded
+        end
+        # encode all
+        filter_codecs.reverse!
+        data_amount = @filtered_data.pos # should be eof
+        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 = @filtered_data.read line_size
+          posb = pos - (1 + line_size) - line_size
+          prev = nil
+          unless posb < 0
+            @filtered_data.pos = posb
+            prev = @filtered_data.read line_size
+          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 << encoded
+        end
+      end
+    end
+
+    #
+    # Re-compress the filtered data.
+    #
+    # All arguments are for Zlib. See the document of Zlib::Deflate.new for more detail.
+    #
+    def compress(
+      level = Zlib::DEFAULT_COMPRESSION,
+      window_bits = Zlib::MAX_WBITS,
+      mem_level = Zlib::DEF_MEM_LEVEL,
+      strategy = Zlib::DEFAULT_STRATEGY
+    )
+      wrap_with_rewind(@compressed_data, @filtered_data) do
+        z = Zlib::Deflate.new level, window_bits, mem_level, strategy
+        until @filtered_data.eof? do
+          buffer_size = 2 ** 16
+          flush = Zlib::NO_FLUSH
+          flush = Zlib::FINISH if @filtered_data.size - @filtered_data.pos < buffer_size
+          @compressed_data << z.deflate(@filtered_data.read(buffer_size), flush)
+        end
+        z.finish
+        z.close
+        truncate_io @compressed_data
+      end
+      @is_compressed_data_modified = false
+      self
+    end
+
+    #
+    # Process each scanlines.
+    #
+    # It takes a block with a parameter. The parameter is 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.
+    #
+    # Here is some examples:
+    #
+    #   pnglitch.each_scanline do |line|
+    #     line.gsub!(/\w/, '0') # replace all alphabetical chars in data
+    #   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)
+    #   end
+    #
+    #   pnglicth.each_scanline do |line|
+    #     line.graft 3          # change all filter to 3 and data remains (it will be a glitch)
+    #   end
+    #
+    # See PNGlitch::Scanline for more details.
+    #
+    # This method is safer than +glitch+ but will be a little bit slow.
+    #
+    # -----
+    #
+    # 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|
+    #     line.change_filter 3
+    #     line.gsub! /\d/, 'x'  # wants to glitch after changing filters.
+    #   end
+    #
+    # To glitch after applying the new filter types, it should be called separately like:
+    #
+    #   pnglicth.each_scanline do |line|
+    #     line.change_filter 3
+    #   end
+    #   pnglicth.each_scanline do |line|
+    #     line.gsub! /\d/, 'x'
+    #   end
+    #
+    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
+          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?
+            is_refilter_needed = true
+          end
+          at += 1
+          pos += @width * @sample_size + 1
+          @filtered_data.pos = pos
+        end
+      end
+      apply_filters(prev_filters, filter_codecs) if is_refilter_needed
+      compress
+    end
+
+    #
+    # Access particular scanline(s) at passed +index_or_range+.
+    #
+    # It returns a single Scanline or an array of Scanline.
+    #
+    def scanline_at index_or_range
+      base = self
+      prev_filters = self.filter_types
+      filter_codecs = nil
+      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|
+        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
+            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
+      end
+      scanlines.size <= 1 ? scanlines.first : scanlines
+    end
+
+    #
+    # Rewrites the width value.
+    #
+    def width= w
+      @head_data.pos = 8
+      while bytes = @head_data.read(8)
+        length, type = bytes.unpack 'Na*'
+        if type == 'IHDR'
+          @head_data << [w].pack('N')
+          @head_data.pos -= 4
+          data = @head_data.read length
+          @head_data << [Zlib.crc32(data, Zlib.crc32(type))].pack('N')
+          break
+        end
+      end
+      @head_data.rewind
+    end
+
+    #
+    # Rewrites the height value.
+    #
+    def height= h
+      @head_data.pos = 8
+      while bytes = @head_data.read(8)
+        length, type = bytes.unpack 'Na*'
+        if type == 'IHDR'
+          @head_data.pos += 4
+          @head_data << [h].pack('N')
+          @head_data.pos -= 8
+          data = @head_data.read length
+          @head_data << [Zlib.crc32(data, Zlib.crc32(type))].pack('N')
+          @head_data.rewind
+          break
+        end
+      end
+      @head_data.rewind
+    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')
+        end
+        io << @tail_data.read
+      end
+      self
+    end
+
+    alias output save
+
+    private
+
+    # Truncates IO's data from current position.
+    def truncate_io io
+      eof = io.pos
+      io.truncate eof
+    end
+
+    # Rewinds given IOs before and after the block.
+    def wrap_with_rewind *io, &block
+      io.each do |i|
+        i.rewind
+      end
+      yield
+      io.each do |i|
+        i.rewind
+      end
+    end
+
+    # Makes warning
+    def warn_if_compressed_data_modified # :nodoc:
+      if @is_compressed_data_modified
+        trace = caller_locations 1, 2
+        message = <<-EOL.gsub(/^\s*/, '')
+          WARNING: `#{trace.first.label}' is called after a modification to the compressed data.
+          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}
+        EOL
+        message = ["\e[33m",  message, "\e[0m"].join if STDOUT.tty?  # color yellow
+        warn ["\n", message, "\n"].join
+      end
+    end
+  end
+end