zpng 0.2.1 → 0.2.2

data/lib/zpng/pixels.rb

@@ -2,18 +2,36 @@ module ZPNG
   class Pixels
     include Enumerable
 
-    def initialize image
-      @image = image
+    module ImageEnum
+      def each
+        @image.height.times do |y|
+          @image.width.times do |x|
+            yield @image[x,y]
+          end
+        end
+      end
     end
 
-    def each
-      @image.height.times do |y|
-        @image.width.times do |x|
-          yield @image[x,y]
+    module ScanLineEnum
+      def each
+        @scanline.width.times do |x|
+          yield @scanline[x]
         end
       end
     end
 
+    def initialize x
+      case x
+      when Image
+        @image = x
+        extend ImageEnum
+      when ScanLine
+        @scanline = x
+        extend ScanLineEnum
+      else raise ArgumentError, "don't know how to enumerate #{x.inspect}"
+      end
+    end
+
     def == other
       self.to_a == other.to_a
     end

data/lib/zpng/readable_struct.rb

@@ -0,0 +1,56 @@
+module ZPNG
+  module ReadableStruct
+
+    def self.new fmt, *args
+      size = fmt.scan(/([a-z])(\d*)/i).map do |f,len|
+        [len.to_i, 1].max *
+          case f
+          when /[aAC]/ then 1
+          when 'v' then 2
+          when 'V','l' then 4
+          when 'Q' then 8
+          else raise "unknown fmt #{f.inspect}"
+          end
+      end.inject(&:+)
+
+      Struct.new( *args ).tap do |x|
+        x.const_set 'FORMAT', fmt
+        x.const_set 'SIZE',  size
+        x.class_eval do
+          include InstanceMethods
+        end
+        x.extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      # src can be IO or String, or anything that responds to :read or :unpack
+      def read src, size = nil
+        size ||= const_get 'SIZE'
+        data =
+          if src.respond_to?(:read)
+            src.read(size).to_s
+          elsif src.respond_to?(:unpack)
+            src
+          else
+            raise "[?] don't know how to read from #{src.inspect}"
+          end
+        if data.size < size
+          $stderr.puts "[!] #{self.to_s} want #{size} bytes, got #{data.size}"
+        end
+        new(*data.unpack(const_get('FORMAT')))
+      end
+    end
+
+    module InstanceMethods
+      def pack
+        to_a.pack self.class.const_get('FORMAT')
+      end
+
+      def empty?
+        to_a.all?{ |t| t == 0 || t.nil? || t.to_s.tr("\x00","").empty? }
+      end
+    end
+
+  end # ReadableStruct
+end # ZPNG

data/lib/zpng/scan_line.rb

@@ -10,7 +10,7 @@ module ZPNG
     attr_accessor :image, :idx, :filter, :offset, :bpp
     attr_writer :decoded_bytes
 
-    def initialize image, idx
+    def initialize image, idx, params={}
       @image,@idx = image,idx
       @bpp = image.hdr.bpp
       raise "[!] zero bpp" if @bpp == 0
@@ -20,9 +20,10 @@ module ZPNG
       @BPP = (@bpp%8 == 0) && (@bpp>>3)
 
       if @image.new?
-        @decoded_bytes = "\x00" * (size-1)
+        @size = params[:size]
+        @decoded_bytes = params[:decoded_bytes] || "\x00" * (size-1)
         @filter = FILTER_NONE
-        @offset = idx*size
+        @offset = params[:offset] || idx*size
       else
         @offset =
           if image.interlaced?
@@ -45,23 +46,29 @@ module ZPNG
 
     # total scanline size in bytes, INCLUDING leading 'filter' byte
     def size
-      w =
-        if image.interlaced?
-          image.adam7.scanline_width(idx)
-        else
-          image.width
+      @size ||=
+        begin
+          if @BPP
+            width*@BPP+1
+          else
+            (width*@bpp/8.0+1).ceil
+          end
         end
-      if @BPP
-        w*@BPP+1
+    end
+
+    # scanline width in pixels
+    def width
+      if image.interlaced?
+        image.adam7.scanline_width(idx)
       else
-        (w*@bpp/8.0+1).ceil
+        image.width
       end
     end
 
     def inspect
       if image.interlaced?
         "#<ZPNG::ScanLine idx=%-2d offset=%-3d width=%-2d size=%-2d bpp=%d filter=%d>" %
-          [idx, offset, image.adam7.scanline_width(idx), size, bpp, filter]
+          [idx, offset, width, size, bpp, filter]
       else
         "#<ZPNG::ScanLine idx=%-2d offset=%-3d size=%-2d bpp=%d filter=%d>" %
           [idx, offset, size, bpp, filter]
@@ -70,14 +77,10 @@ module ZPNG
 
     def to_ascii *args
       @image.width.times.map do |i|
-        decode_pixel(i).to_ascii(*args)
+        self[i].to_ascii(*args)
       end.join
     end
 
-    def [] x
-      decode_pixel(x)
-    end
-
     def []= x, color
       case image.hdr.color
       when COLOR_INDEXED                # ALLOWED_DEPTHS: 1, 2, 4, 8
@@ -89,9 +92,9 @@ module ZPNG
         raise "invalid shift #{shift}" if shift < 0 || shift > 7
 
         pos = x*@bpp/8
-        b = decoded_bytes[pos].ord
+        b = decoded_bytes.getbyte(pos)
         b = (b & (0xff-(mask<<shift))) | ((color_idx & mask) << shift)
-        decoded_bytes[pos] = b.chr
+        decoded_bytes.setbyte(pos, b)
         # TODO: transparency in TRNS
 
       when COLOR_GRAYSCALE              # ALLOWED_DEPTHS: 1, 2, 4, 8, 16
@@ -137,10 +140,10 @@ module ZPNG
       end # case image.hdr.color
     end
 
-    def decode_pixel x
+    def [] x
       raw =
         if @BPP
-          # 8, 16 or 32 bits per pixel
+          # 8, 16, 24, 32, 48 bits per pixel
           decoded_bytes[x*@BPP, @BPP]
         else
           # 1, 2 or 4 bits per pixel
@@ -192,7 +195,12 @@ module ZPNG
         color =
           case @bpp
           when 24                     # RGB  8 bits per sample = 24bpp
-            Color.new(*raw.unpack('C3'))
+            if image.trns
+              extend Mixins::RGB24_TRNS
+            else
+              extend Mixins::RGB24
+            end
+            return self[x]
           when 48                     # RGB 16 bits per sample = 48bpp
             Color.new(*raw.unpack('n3'), :depth => 16)
           else raise "COLOR_RGB unexpected bpp #@bpp"
@@ -213,7 +221,8 @@ module ZPNG
       when COLOR_RGBA                   # ALLOWED_DEPTHS: 8, 16
         case @bpp
         when 32                         # RGBA  8-bit/sample
-          return Color.new(*raw.unpack('C4'))
+          extend Mixins::RGBA32
+          return self[x]
         when 64                         # RGBA 16-bit/sample
           return Color.new(*raw.unpack('n4'), :depth => 16 )
         else raise "COLOR_RGBA unexpected bpp #@bpp"
@@ -229,15 +238,55 @@ module ZPNG
       #raise if caller.size > 50
       @decoded_bytes ||=
         begin
+          imagedata = @image.imagedata
+
           # number of bytes per complete pixel, rounding up to one
           bpp1 = (@bpp/8.0).ceil
 
-          s = ''
-          (size-1).times do |i|
-            b0 = (i-bpp1) >= 0 ? s[i-bpp1] : nil
-            s[i] = decode_byte(i, b0, bpp1)
+          case @filter
+
+          when FILTER_NONE    # 0
+            s = imagedata[@offset+1, size-1]
+
+          when FILTER_SUB     # 1
+            s = "\x00" * (size-1)
+            s[0,bpp1] = imagedata[@offset+1,bpp1]
+            bpp1.upto(size-2) do |i|
+              s.setbyte(i, imagedata.getbyte(@offset+i+1) + s.getbyte(i-bpp1))
+            end
+
+          when FILTER_UP      # 2
+            s = "\x00" * (size-1)
+            0.upto(size-2) do |i|
+              s.setbyte(i, imagedata.getbyte(@offset+i+1) + prev_scanline_byte(i))
+            end
+
+          when FILTER_AVERAGE # 3
+            s = "\x00" * (size-1)
+            0.upto(bpp1-1) do |i|
+              s.setbyte(i, imagedata.getbyte(@offset+i+1) + prev_scanline_byte(i)/2)
+            end
+            bpp1.upto(size-2) do |i|
+              s.setbyte(i,
+                imagedata.getbyte(@offset+i+1) + (s.getbyte(i-bpp1) + prev_scanline_byte(i))/2
+              )
+            end
+
+          when FILTER_PAETH   # 4
+            s = "\x00" * (size-1)
+            0.upto(bpp1-1) do |i|
+              s.setbyte(i, imagedata.getbyte(@offset+i+1) + prev_scanline_byte(i))
+            end
+            bpp1.upto(size-2) do |i|
+              s.setbyte(i,
+                imagedata.getbyte(@offset+i+1) +
+                paeth_predictor(s.getbyte(i-bpp1), prev_scanline_byte(i), prev_scanline_byte(i-bpp1))
+              )
+            end
+
+          else raise "invalid ScanLine filter #{@filter}"
           end
-#          print Hexdump.dump(s[0,16])
+
           s
         end
     end
@@ -254,49 +303,16 @@ module ZPNG
     private
 
     def prev_scanline_byte x
+      # defining instance methods gives 10-15% speed boost
       if image.interlaced?
-        # When the image is interlaced, each pass of the interlace pattern is
-        # treated as an independent image for filtering purposes
-        image.adam7.pass_start?(@idx) ? 0 : image.scanlines[@idx-1].decoded_bytes[x].ord
+        extend Mixins::Interlaced
       elsif @idx > 0
-        image.scanlines[@idx-1].decoded_bytes[x].ord
-      else
-        0
-      end
-    end
-
-    def decode_byte x, b0, bpp1
-      raw = @image.imagedata[@offset+x+1]
-
-      unless raw
-        STDERR.puts "[!] #{self.class}: ##@idx: no data at pos #{x}".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
-        ((raw.ord + prev_scanline_byte(x)) & 0xff).chr
-
-      when FILTER_AVERAGE # 3
-        prev = (b0 && b0.ord) || 0
-        prior = prev_scanline_byte(x)
-        ((raw.ord + (prev + prior)/2) & 0xff).chr
-
-      when FILTER_PAETH   # 4
-        pa = (b0 && b0.ord) || 0
-        pb = prev_scanline_byte(x)
-        pc = b0 ? prev_scanline_byte(x-bpp1) : 0
-        ((raw.ord + paeth_predictor(pa, pb, pc)) & 0xff).chr
+        extend Mixins::NotFirstLine
       else
-        raise "invalid ScanLine filter #{@filter}"
+        extend Mixins::FirstLine
       end
+      # call newly created method
+      prev_scanline_byte x
     end
 
     def paeth_predictor a,b,c
@@ -309,6 +325,7 @@ module ZPNG
 
     public
     def crop! x, w
+      @size = nil # unmemoize self size b/c it's changed after crop
       if @BPP
         # great, crop is byte-aligned! :)
         decoded_bytes[0,x*@BPP]   = ''
@@ -356,5 +373,15 @@ module ZPNG
       # we export in FILTER_NONE mode
       FILTER_NONE.chr + decoded_bytes
     end
+
+    def each_pixel
+      width.times do |i|
+        yield self[i], i
+      end
+    end
+
+    def pixels
+      Pixels.new(self)
+    end
   end
 end

data/lib/zpng/scan_line/mixins.rb

@@ -0,0 +1,74 @@
+module ZPNG
+  class ScanLine
+    module Mixins
+
+      # scanline decoding
+
+      module Interlaced
+        def prev_scanline_byte x
+          # When the image is interlaced, each pass of the interlace pattern is
+          # treated as an independent image for filtering purposes
+          image.adam7.pass_start?(@idx) ? 0 : image.scanlines[@idx-1].decoded_bytes.getbyte(x)
+        end
+      end
+
+      module NotFirstLine
+        def prev_scanline_byte x
+          image.scanlines[@idx-1].decoded_bytes.getbyte(x)
+        end
+      end
+
+      module FirstLine
+        def prev_scanline_byte x
+          0
+        end
+      end
+
+      # pixel access
+
+      # RGB  8 bits per sample = 24bpp
+      module RGB24
+        def [] x
+          t = x*3
+          # color_class is for (limited) BMP support
+          image.color_class.new(
+            decoded_bytes.getbyte(t),
+            decoded_bytes.getbyte(t+1),
+            decoded_bytes.getbyte(t+2)
+          )
+        end
+      end
+
+      # if image has tRNS chunk - 10% slower than RGB24
+      module RGB24_TRNS
+        def [] x
+          t = x*3
+          # color_class is for (limited) BMP support
+          color = image.color_class.new(
+            decoded_bytes.getbyte(t),
+            decoded_bytes.getbyte(t+1),
+            decoded_bytes.getbyte(t+2)
+          )
+          color.alpha = image._alpha_color(color)
+          color
+        end
+      end
+
+      # RGBA 8 bits per sample = 32bpp
+      module RGBA32
+        def [] x
+          # substring  => 1.50s on 270_000 pixels
+          # getbyte(s) => 1.25s on 270_000 pixels
+          t = x*4
+          image.color_class.new(
+            decoded_bytes.getbyte(t),
+            decoded_bytes.getbyte(t+1),
+            decoded_bytes.getbyte(t+2),
+            decoded_bytes.getbyte(t+3)
+          )
+        end
+      end
+
+    end # Mixins
+  end # ScanLine
+end # ZPNG

data/lib/zpng/string_ext.rb

@@ -6,6 +6,9 @@ class String
       define_method color do
         color(color)
       end
+      define_method "bright_#{color}" do
+        color(color).bright
+      end
     end
   end