zpng 0.0.1

data/lib/zpng/chunk.rb

@@ -0,0 +1,133 @@
+module ZPNG
+  class Chunk
+    attr_accessor :size, :type, :data, :crc
+
+    def self.from_stream io
+      size, type = io.read(8).unpack('Na4')
+      io.seek(-8,IO::SEEK_CUR)
+      begin
+        if const_defined?(type.upcase)
+          klass = const_get(type.upcase)
+          klass.new(io)
+        else
+          Chunk.new(io)
+        end
+      rescue NameError
+        # invalid chunk type?
+        Chunk.new(io)
+      end
+    end
+
+    def initialize io
+      @size, @type = io.read(8).unpack('Na4')
+      @data        = io.read(size)
+      @crc         = io.read(4).to_s.unpack('N').first
+    end
+
+    def export
+      @data = self.export_data # virtual
+      @crc = Zlib.crc32(data, Zlib.crc32(type))
+      [@size,@type].pack('Na4') + @data + [@crc].pack('N')
+    end
+
+    def export_data
+      #STDERR.puts "[!] Chunk::#{type} must realize 'export_data' virtual method".yellow if @size != 0
+      @data
+    end
+
+    def inspect
+      size = @size ? sprintf("%5d",@size) : sprintf("%5s","???")
+      crc  = @crc  ? sprintf("%08x",@crc) : sprintf("%8s","???")
+      type = @type.to_s.gsub(/[^0-9a-z]/i){ |x| sprintf("\\x%02X",x.ord) }
+      sprintf("#<ZPNG::Chunk  %4s size=%s, crc=%s >", type, size, crc)
+    end
+
+    def crc_ok?
+      expected_crc = Zlib.crc32(data, Zlib.crc32(type))
+      expected_crc == crc
+    end
+
+    class IHDR < Chunk
+      attr_accessor :width, :height, :depth, :color, :compression, :filter, :interlace
+
+      PALETTE_USED = 1
+      COLOR_USED   = 2
+      ALPHA_USED   = 4
+
+      COLOR_GRAYSCALE  = 0  # Each pixel is a grayscale sample
+      COLOR_RGB        = 2  # Each pixel is an R,G,B triple.
+      COLOR_INDEXED    = 3  # Each pixel is a palette index; a PLTE chunk must appear.
+      COLOR_GRAY_ALPHA = 4  # Each pixel is a grayscale sample, followed by an alpha sample.
+      COLOR_RGBA       = 6  # Each pixel is an R,G,B triple, followed by an alpha sample.
+
+      SAMPLES_PER_COLOR = {
+        COLOR_GRAYSCALE  => 1,
+        COLOR_RGB        => 3,
+        COLOR_INDEXED    => 1,
+        COLOR_GRAY_ALPHA => 2,
+        COLOR_RGBA       => 4
+      }
+
+      FORMAT = 'NNC5'
+
+      def initialize io
+        super
+        @width, @height, @depth, @color, @compression, @filter, @interlace = data.unpack(FORMAT)
+      end
+
+      def export_data
+        [@width, @height, @depth, @color, @compression, @filter, @interlace].pack(FORMAT)
+      end
+
+      # bits per pixel
+      def bpp
+        SAMPLES_PER_COLOR[@color] * depth
+      end
+
+      def color_used?
+        (@color & COLOR_USED) != 0
+      end
+
+      def grayscale?
+        !color_used?
+      end
+
+      def palette_used?
+        (@color & PALETTE_USED) != 0
+      end
+
+      def alpha_used?
+        (@color & ALPHA_USED) != 0
+      end
+
+      def inspect
+        super.sub(/ *>$/,'') + ", " +
+          (instance_variables-[:@type, :@crc, :@data, :@size]).
+          map{ |var| "#{var.to_s.tr('@','')}=#{instance_variable_get(var)}" }.
+          join(", ") + ">"
+      end
+    end
+
+    class PLTE < Chunk
+      def [] idx
+        rgb = @data[idx*3,3]
+        rgb && ZPNG::Color.new(*rgb.split('').map(&:ord))
+      end
+
+      def ncolors
+        @size/3
+      end
+
+      def index color
+        ncolors.times do |i|
+          c = self[i]
+          return i if c.r == color.r && c.g == color.g && c.b == color.b
+        end
+        nil
+      end
+    end
+
+    class IEND < Chunk
+    end
+  end
+end

data/lib/zpng/cli.rb

@@ -0,0 +1,90 @@
+require 'zpng'
+require 'optparse'
+require 'hexdump'
+require 'pp'
+
+class ZPNG::CLI
+
+  ACTIONS = {
+    'info'      => 'General image info',
+    'chunks'    => 'Show file chunks (default)',
+    'ascii'     => 'Try to display image as ASCII (works best with monochrome images)',
+    'scanlines' => 'Show scanlines info',
+    'palette'   => 'Show palette'
+  }
+  DEFAULT_ACTIONS = %w'info chunks'
+
+  def initialize argv = ARGV
+    @argv = argv
+  end
+
+  def run
+    @actions = []
+    @options = { :verbose => 0 }
+    optparser = OptionParser.new do |opts|
+      opts.banner = "Usage: zpng [options]"
+
+      opts.on "-v", "--verbose", "Run verbosely (can be used multiple times)" do |v|
+        @options[:verbose] += 1
+      end
+      opts.on "-q", "--quiet", "Silent any warnings (can be used multiple times)" do |v|
+        @options[:verbose] -= 1
+      end
+
+      ACTIONS.each do |t,desc|
+        opts.on *[ "-#{t[0].upcase}", "--#{t}", desc, eval("lambda{ |_| @actions << :#{t} }") ]
+      end
+    end
+
+    if (argv = optparser.parse(@argv)).empty?
+      puts optparser.help
+      return
+    end
+
+    @actions = DEFAULT_ACTIONS if @actions.empty?
+
+    argv.each_with_index do |fname,idx|
+      @need_fname_header = (argv.size > 1)
+      @file_idx  = idx
+      @file_name = fname
+
+      @zpng = load_file fname
+
+      @actions.each do |action|
+        self.send(action) if self.respond_to?(action)
+      end
+    end
+  rescue Errno::EPIPE
+    # output interrupt, f.ex. when piping output to a 'head' command
+    # prevents a 'Broken pipe - <STDOUT> (Errno::EPIPE)' message
+  end
+
+  def load_file fname
+    @img = ZPNG::Image.new fname
+  end
+
+  def info
+    puts "[.] image size #{@img.width}x#{@img.height}"
+    puts "[.] uncompressed imagedata size = #{@img.imagedata.size} bytes"
+    puts "[.] palette = #{@img.palette}" if @img.palette
+  end
+
+  def chunks
+    @img.dump
+  end
+
+  def ascii
+    puts @img.to_s
+  end
+
+  def scanlines
+    pp @img.scanlines
+  end
+
+  def palette
+    if @img.palette
+      pp @img.palette
+      Hexdump.dump @img.palette.data, :width => 6*3
+    end
+  end
+end

data/lib/zpng/color.rb

@@ -0,0 +1,25 @@
+module ZPNG
+  class Color < Struct.new(:r,:g,:b,:a)
+
+    alias :alpha :a
+
+    BLACK = Color.new(0,0,0,0xff)
+    WHITE = Color.new(0xff,0xff,0xff,0xff)
+
+    def white?
+      r == 0xff && g == 0xff && b == 0xff
+    end
+
+    def black?
+      r == 0 && g == 0 && b == 0
+    end
+
+    def to_grayscale
+      (r+g+b)/3
+    end
+
+    def to_s
+      "%02X%02X%02X" % [r,g,b]
+    end
+  end
+end

data/lib/zpng/image.rb

@@ -0,0 +1,130 @@
+module ZPNG
+  class Image
+    attr_accessor :data, :header, :chunks, :scanlines, :imagedata, :palette
+    alias :hdr :header
+
+    PNG_HDR = "\x89PNG\x0d\x0a\x1a\x0a"
+
+    def initialize x = nil
+      if x
+        if x[PNG_HDR]
+          # raw image data
+          @data = x
+        else
+          # filename
+          @data = File.binread(x)
+        end
+      end
+
+      d = data[0,PNG_HDR.size]
+      if d != PNG_HDR
+        puts "[!] first #{PNG_HDR.size} bytes must be #{PNG_HDR.inspect}, but got #{d.inspect}".red
+      end
+
+      io = StringIO.new(data)
+      io.seek PNG_HDR.size
+      @chunks = []
+      while !io.eof?
+        chunk = Chunk.from_stream(io)
+        @chunks << chunk
+        case chunk
+        when Chunk::IHDR
+          @header = chunk
+        when Chunk::PLTE
+          @palette = chunk
+        when Chunk::IEND
+          break
+        end
+      end
+      unless io.eof?
+        offset    = io.tell
+        extradata = io.read
+        puts "[?] #{extradata.size} bytes of extra data after image end (IEND), offset = 0x#{offset.to_s(16)}".red
+      end
+    end
+
+    def dump
+      @chunks.each do |chunk|
+        puts "[.] #{chunk.inspect} #{chunk.crc_ok? ? 'CRC OK'.green : 'CRC ERROR'.red}"
+      end
+    end
+
+    def width
+      @header && @header.width
+    end
+
+    def height
+      @header && @header.height
+    end
+
+    def imagedata
+      if @header
+        raise "only non-interlaced mode is supported for imagedata" if @header.interlace != 0
+      else
+        puts "[?] no image header, assuming non-interlaced RGB".yellow
+      end
+      @imagedata ||= Zlib::Inflate.inflate(@chunks.find_all{ |c| c.type == "IDAT" }.map(&:data).join)
+    end
+
+    def [] x, y
+      scanlines[y][x]
+    end
+
+    def []= x, y, newpixel
+      # we must decode all scanlines before doing any modifications
+      # or scanlines decoded AFTER modification of UPPER ones will be decoded wrong
+      _decode_all_scanlines unless @_all_scanlines_decoded
+      scanlines[y][x] = newpixel
+    end
+
+    def _decode_all_scanlines
+      scanlines.each(&:decode!)
+      @_all_scanlines_decoded = true
+    end
+
+    def scanlines
+      @scanlines ||=
+        begin
+          r = []
+          height.times do |i|
+            r << ScanLine.new(self,i)
+          end
+          r
+        end
+    end
+
+    def to_s h={}
+      scanlines.map{ |l| l.to_s(h) }.join("\n")
+    end
+
+    def extract_block x,y=nil,w=nil,h=nil
+      if x.is_a?(Hash)
+        Block.new(self,x[:x], x[:y], x[:width], x[:height])
+      else
+        Block.new(self,x,y,w,h)
+      end
+    end
+
+    def each_block bw,bh, &block
+      0.upto(height/bh-1) do |by|
+        0.upto(width/bw-1) do |bx|
+          b = extract_block(bx*bw, by*bh, bw, bh)
+          yield b
+        end
+      end
+    end
+
+    def export
+      imagedata # fill @imagedata, if not already filled
+
+      # delete redundant IDAT chunks
+      first_idat = @chunks.find{ |c| c.type == 'IDAT' }
+      @chunks.delete_if{ |c| c.type == 'IDAT' && c != first_idat }
+
+      # fill first_idat @data with compressed imagedata
+      first_idat.data = Zlib::Deflate.deflate(scanlines.map(&:export).join, 9)
+
+      PNG_HDR + @chunks.map(&:export).join
+    end
+  end
+end

data/lib/zpng/scan_line.rb

@@ -0,0 +1,222 @@
+module ZPNG
+  class ScanLine
+    FILTER_NONE           = 0
+    FILTER_SUB            = 1
+    FILTER_UP             = 2
+    FILTER_AVERAGE        = 3
+    FILTER_PAETH          = 4
+
+    attr_accessor :image, :idx, :filter, :offset
+
+    def initialize image, idx
+      @image,@idx = image,idx
+      @bpp = image.hdr.bpp
+      raise "[!] zero bpp" if @bpp == 0
+      if @BPP = (@bpp%8 == 0) && (@bpp>>3)
+        @offset = idx*(image.width*@BPP+1)
+      else
+        @offset = idx*(image.width*@bpp/8.0+1).ceil
+      end
+      @filter = image.imagedata[@offset].ord
+      @offset += 1
+    end
+
+    def inspect
+      "#<ZPNG::ScanLine " + (instance_variables-[:@image, :@decoded]).
+          map{ |var| "#{var.to_s.tr('@','')}=#{instance_variable_get(var)}" }.
+          join(", ") + ">"
+    end
+
+    def to_s h={}
+      white   = h[:white]   || ' '
+      black   = h[:black]   || '#'
+      unknown = h[:unknown] || '?'
+
+      @image.width.times.map do |i|
+        px = decode_pixel(i)
+        px.white?? white : (px.black?? black : unknown)
+      end.join
+    end
+
+    def [] x
+      decode_pixel(x)
+    end
+
+    def []= x, newcolor
+      case @bpp
+      when 1
+        flag =
+          if image.hdr.palette_used?
+            idx = image.palette.index(newcolor)
+            raise "no color #{newcolor.inspect} in palette" unless idx
+            idx == 1
+          else
+            if newcolor.white?
+              true
+            elsif newcolor.black?
+              false
+            else
+              raise "1bpp pixel can only be WHITE or BLACK, got #{newcolor.inspect}"
+            end
+          end
+        if flag
+          # turn pixel on
+          decoded_bytes[x/8] = (decoded_bytes[x/8].ord | (1<<(7-(x%8)))).chr
+        else
+          # turn pixel off
+          decoded_bytes[x/8] = (decoded_bytes[x/8].ord & (0xff-(1<<(7-(x%8))))).chr
+        end
+      when 8
+        if image.hdr.palette_used?
+          decoded_bytes[x] = (image.palette.index(newcolor)).chr
+        else
+          decoded_bytes[x] = ((newcolor.r + newcolor.g + newcolor.b)/3).chr
+        end
+      when 16
+        if image.hdr.palette_used? && image.hdr.alpha_used?
+          decoded_bytes[x*2] = (image.palette.index(newcolor)).chr
+          decoded_bytes[x*2+1] = (newcolor.alpha || 0xff).chr
+        elsif image.hdr.grayscale? && image.hdr.alpha_used?
+          decoded_bytes[x*2] = newcolor.to_grayscale.chr
+          decoded_bytes[x*2+1] = (newcolor.alpha || 0xff).chr
+        else
+          raise "unexpected colormode #{image.hdr.inspect}"
+        end
+      when 24
+        decoded_bytes[x*3,3] = [newcolor.r, newcolor.g, newcolor.b].map(&:chr).join
+      when 32
+        decoded_bytes[x*4,4] = [newcolor.r, newcolor.g, newcolor.b, newcolor.a].map(&:chr).join
+      else raise "unsupported bpp #{@bpp}"
+      end
+    end
+
+    def decode_pixel x
+      raw =
+        if @BPP
+          # 8, 16 or 32 bits per pixel
+          decoded_bytes[x*@BPP, @BPP]
+        else
+          # 1, 2 or 4 bits per pixel
+          decoded_bytes[x*@bpp/8, (@bpp/8.0).ceil]
+        end
+
+      r = g = b = a = nil
+
+      colormode = image.hdr.color
+
+      if image.hdr.palette_used?
+        idx =
+          case @bpp
+          when 1
+            # needed for palette
+            (raw.ord & (1<<(7-(x%8)))) == 0 ? 0 : 1
+          when 8
+            raw.ord
+          when 16
+            raw[0].ord
+          else raise "unexpected bpp #{@bpp}"
+          end
+
+        return image.palette[idx]
+      end
+
+      case @bpp
+      when 1
+        r=g=b= (raw.ord & (1<<(7-(x%8)))) == 0 ? 0 : 0xff
+      when 8
+        if colormode == ZPNG::Chunk::IHDR::COLOR_GRAYSCALE
+          r=g=b= raw.ord
+        else
+          raise "unexpected colormode #{colormode} for bpp #{@bpp}"
+        end
+      when 16
+        if colormode == ZPNG::Chunk::IHDR::COLOR_GRAY_ALPHA
+          r=g=b= raw[0].ord
+          a = raw[1].ord
+        else
+          raise "unexpected colormode #{colormode} for bpp #{@bpp}"
+        end
+      when 24
+        r,g,b = raw.split('').map(&:ord)
+      when 32
+        r,g,b,a = raw.split('').map(&:ord)
+      else raise "unexpected bpp #{@bpp}"
+      end
+
+      Color.new(r,g,b,a)
+    end
+
+    def decoded_bytes
+      @decoded_bytes ||=
+        begin
+          # number of bytes per complete pixel, rounding up to one
+          bpp1 = (@bpp/8.0).ceil
+
+          # bytes in one scanline
+          nbytes = (image.width*@bpp/8.0).ceil
+
+          s = ''
+          nbytes.times do |i|
+            b0 = (i-bpp1) >= 0 ? s[i-bpp1] : nil
+            s[i] = decode_byte(i, b0, bpp1)
+          end
+#          print Hexdump.dump(s[0,16])
+          s
+        end
+    end
+
+    def decode!
+      decoded_bytes
+      true
+    end
+
+    def decode_byte x, b0, bpp1
+      raw = @image.imagedata[@offset+x]
+
+      unless raw
+        STDERR.puts "[!] not enough bytes at pos #{x} of scanline #@idx".red
+        raw = 0.chr
+      end
+
+      case @filter
+      when FILTER_NONE  # 0
+        raw
+
+      when FILTER_SUB   # 1
+        return raw unless b0
+        ((raw.ord + b0.ord) & 0xff).chr
+
+      when FILTER_UP    # 2
+        return raw if @idx == 0
+        prev = @image.scanlines[@idx-1].decoded_bytes[x]
+        ((raw.ord + prev.ord) & 0xff).chr
+
+      when FILTER_AVERAGE # 3
+        prev = (b0 && b0.ord) || 0
+        prior = (@idx > 0) ? @image.scanlines[@idx-1].decoded_bytes[x].ord : 0
+        ((raw.ord + (prev + prior)/2) & 0xff).chr
+
+      when FILTER_PAETH # 4
+        pa = (b0 && b0.ord) || 0
+        pb = (@idx > 0) ? @image.scanlines[@idx-1].decoded_bytes[x].ord : 0
+        pc = (b0 && @idx > 0) ? @image.scanlines[@idx-1].decoded_bytes[x-bpp1].ord : 0
+        ((raw.ord + paeth_predictor(pa, pb, pc)) & 0xff).chr
+      else
+        raise "invalid ScanLine filter #{@filter}"
+      end
+    end
+
+    def paeth_predictor a,b,c
+      p = a + b - c
+      pa = (p - a).abs
+      pb = (p - b).abs
+      pc = (p - c).abs
+      (pa <= pb) ? (pa <= pc ? a : c) : (pb <= pc ? b : c)
+    end
+
+    def export
+      # we export in FILTER_NONE mode
+      "\x00" + decoded_bytes
+    end
+  end
+end