chunky_png 0.5.1 → 0.5.2

data/chunky_png.gemspec

@@ -3,7 +3,7 @@ Gem::Specification.new do |s|
 
   # Do not change the version and date fields by hand. This will be done
   # automatically by the gem release script.
-  s.version = "0.5.1"
+  s.version = "0.5.2"
   s.date    = "2010-01-16"
 
   s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"

data/lib/chunky_png.rb

@@ -22,7 +22,7 @@ module ChunkyPNG
 
   # The current version of ChunkyPNG. This value will be updated automatically
   # by them gem:release rake task.
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 
   ###################################################
   # PNG international standard defined constants

data/lib/chunky_png/canvas/adam7_interlacing.rb

@@ -26,8 +26,8 @@ module ChunkyPNG
 
       def adam7_merge_pass(pass, canvas, subcanvas)
         m_o = adam7_multiplier_offset(pass)
-        0.upto(subcanvas.height - 1) do |y|
-          0.upto(subcanvas.width - 1) do |x|
+        for y in 0...subcanvas.height do
+          for x in 0...subcanvas.width do
             new_x = x * m_o[:x_multiplier] + m_o[:x_offset]
             new_y = y * m_o[:y_multiplier] + m_o[:y_offset]
             canvas[new_x, new_y] = subcanvas[x, y]

data/lib/chunky_png/canvas/png_decoding.rb

@@ -5,6 +5,8 @@ module ChunkyPNG
     # The datastream can be provided as filename, string or IO object.
     module PNGDecoding
 
+      attr_accessor :decoding_palette
+
       def from_blob(str)
         from_datastream(ChunkyPNG::Datastream.from_blob(str))
       end
@@ -26,37 +28,59 @@ module ChunkyPNG
         height     = ds.header_chunk.height
         color_mode = ds.header_chunk.color
         interlace  = ds.header_chunk.interlace
-        palette    = ChunkyPNG::Palette.from_chunks(ds.palette_chunk, ds.transparency_chunk)
-        stream     = ChunkyPNG::Chunk::ImageData.combine_chunks(ds.data_chunks)
-        decode_png_pixelstream(stream, width, height, color_mode, palette, interlace)
+        
+        self.decoding_palette = ChunkyPNG::Palette.from_chunks(ds.palette_chunk, ds.transparency_chunk)
+        pixelstream           = ChunkyPNG::Chunk::ImageData.combine_chunks(ds.data_chunks)
+        
+        decode_png_pixelstream(pixelstream, width, height, color_mode, interlace)
       end
 
-      def decode_png_pixelstream(stream, width, height, color_mode = ChunkyPNG::COLOR_TRUECOLOR, palette = nil, interlace = ChunkyPNG::INTERLACING_NONE)
-        raise "This palette is not suitable for decoding!" if palette && !palette.can_decode?
-
-        pixel_size    = Color.bytesize(color_mode)
-        pixel_decoder = case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR       then lambda { |bytes| ChunkyPNG::Color.rgb(*bytes) }
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then lambda { |bytes| ChunkyPNG::Color.rgba(*bytes) }
-          when ChunkyPNG::COLOR_INDEXED         then lambda { |bytes| palette[bytes.first] }
-          when ChunkyPNG::COLOR_GRAYSCALE       then lambda { |bytes| ChunkyPNG::Color.grayscale(*bytes) }
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then lambda { |bytes| ChunkyPNG::Color.grayscale(*bytes) }
-          else raise "No suitable pixel decoder found for color mode #{color_mode}!"
-        end
+      def decode_png_pixelstream(stream, width, height, color_mode = ChunkyPNG::COLOR_TRUECOLOR, interlace = ChunkyPNG::INTERLACING_NONE)
+        raise "This palette is not suitable for decoding!" if decoding_palette && !decoding_palette.can_decode?
 
         return case interlace
-          when ChunkyPNG::INTERLACING_NONE  then decode_png_without_interlacing(stream, width, height, pixel_size, pixel_decoder)
-          when ChunkyPNG::INTERLACING_ADAM7 then decode_png_with_adam7_interlacing(stream, width, height, pixel_size, pixel_decoder)
+          when ChunkyPNG::INTERLACING_NONE  then decode_png_without_interlacing(stream, width, height, color_mode)
+          when ChunkyPNG::INTERLACING_ADAM7 then decode_png_with_adam7_interlacing(stream, width, height, color_mode)
           else raise "Don't know how the handle interlacing method #{interlace}!"
         end
       end
 
       protected
 
-      def decode_png_image_pass(stream, width, height, pixel_size, pixel_decoder, start_pos = 0)
-        pixels = []
+      def decode_png_without_interlacing(stream, width, height, color_mode)
+        decode_png_image_pass(stream, width, height, color_mode)
+      end
 
+      def decode_png_with_adam7_interlacing(stream, width, height, color_mode)
+        canvas     = ChunkyPNG::Canvas.new(width, height)
+        pixel_size = Color.bytesize(color_mode)
+        start_pos  = 0
+        for pass in 0...7 do
+          sm_width, sm_height = adam7_pass_size(pass, width, height)
+          sm = decode_png_image_pass(stream, sm_width, sm_height, color_mode, start_pos)
+          adam7_merge_pass(pass, canvas, sm)
+          start_pos += (sm_width * sm_height * pixel_size) + sm_height
+        end
+        canvas
+      end
+
+      def decode_png_image_pass(stream, width, height, color_mode, start_pos = 0)
+        
+        pixel_size    = Color.bytesize(color_mode)
+        pixel_decoder = case color_mode
+          when ChunkyPNG::COLOR_TRUECOLOR       then lambda { |bytes| ChunkyPNG::Color.rgb(*bytes) }
+          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then lambda { |bytes| ChunkyPNG::Color.rgba(*bytes) }
+          when ChunkyPNG::COLOR_INDEXED         then lambda { |bytes| decoding_palette[bytes.first] }
+          when ChunkyPNG::COLOR_GRAYSCALE       then lambda { |bytes| ChunkyPNG::Color.grayscale(*bytes) }
+          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then lambda { |bytes| ChunkyPNG::Color.grayscale_alpha(*bytes) }
+          else raise "No suitable pixel decoder found for color mode #{color_mode}!"
+        end
+        
+        pixels = []
         if width > 0
+          
+          raise "Invalid stream length!" unless stream.length - start_pos >= width * height * pixel_size + height
+          
           decoded_bytes = Array.new(width * pixel_size, 0)
           for line_no in 0...height do
 
@@ -75,22 +99,7 @@ module ChunkyPNG
         new(width, height, pixels)
       end
 
-      def decode_png_without_interlacing(stream, width, height, pixel_size, pixel_decoder)
-        raise "Invalid stream length!" unless stream.length == width * height * pixel_size + height
-        decode_png_image_pass(stream, width, height, pixel_size, pixel_decoder)
-      end
 
-      def decode_png_with_adam7_interlacing(stream, width, height, pixel_size, pixel_decoder)
-        start_pos = 0
-        canvas = ChunkyPNG::Canvas.new(width, height)
-        0.upto(6) do |pass|
-          sm_width, sm_height = adam7_pass_size(pass, width, height)
-          sm = decode_png_image_pass(stream, sm_width, sm_height, pixel_size, pixel_decoder, start_pos)
-          adam7_merge_pass(pass, canvas, sm)
-          start_pos += (sm_width * sm_height * pixel_size) + sm_height
-        end
-        canvas
-      end
 
       def decode_png_scanline(filter, bytes, previous_bytes, pixelsize = 3)
         case filter
@@ -121,7 +130,7 @@ module ChunkyPNG
         bytes.each_with_index do |byte, i|
           a = (i >= pixelsize) ? bytes[i - pixelsize] : 0
           b = previous_bytes[i]
-          bytes[i] = (byte + (a + b / 2).floor) % 256
+          bytes[i] = (byte + ((a + b) >> 1)) % 256
         end
         bytes
       end

data/lib/chunky_png/canvas/png_encoding.rb

@@ -5,11 +5,8 @@ module ChunkyPNG
     #
     module PNGEncoding
 
-      TRUECOLOR_ENCODER       = lambda { |color| Color.to_truecolor_bytes(color) }
-      TRUECOLOR_ALPHA_ENCODER = lambda { |color| Color.to_truecolor_alpha_bytes(color) }
-      GRAYSCALE_ENCODER       = lambda { |color| Color.to_grayscale_bytes(color) }
-      GRAYSCALE_ALPHA_ENCODER = lambda { |color| Color.to_grayscale_alpha_bytes(color) }
-      
+      attr_accessor :encoding_palette
+
       def write(io, constraints = {})
         to_datastream(constraints).write(io)
       end
@@ -46,11 +43,11 @@ module ChunkyPNG
         result[:header] = { :width => width, :height => height, :color => encoding[:color_mode], :interlace => encoding[:interlace] }
 
         if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
-          result[:palette_chunk]      = encoding[:palette].to_plte_chunk
-          result[:transparency_chunk] = encoding[:palette].to_trns_chunk unless encoding[:palette].opaque?
+          result[:palette_chunk]      = encoding_palette.to_plte_chunk
+          result[:transparency_chunk] = encoding_palette.to_trns_chunk unless encoding_palette.opaque?
         end
 
-        result[:pixelstream] = encode_png_pixelstream(encoding[:color_mode], encoding[:palette], encoding[:interlace])
+        result[:pixelstream] = encode_png_pixelstream(encoding[:color_mode], encoding[:interlace])
         return result
       end
 
@@ -66,10 +63,12 @@ module ChunkyPNG
         
         # Do not create a pallete when the encoding is given and does not require a palette.
         if encoding[:color_mode]
-          encoding[:palette]    ||= palette if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
+          if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
+            self.encoding_palette = self.palette 
+          end
         else
-          encoding[:palette]    ||= palette
-          encoding[:color_mode] ||= encoding[:palette].best_colormode
+          self.encoding_palette = self.palette
+          encoding[:color_mode] ||= encoding_palette.best_colormode
         end
         
         encoding[:interlace] = case encoding[:interlace]
@@ -81,52 +80,57 @@ module ChunkyPNG
         return encoding
       end
       
-      def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, palette = nil, interlace = ChunkyPNG::INTERLACING_NONE)
+      def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, interlace = ChunkyPNG::INTERLACING_NONE)
 
-        if color_mode == ChunkyPNG::COLOR_INDEXED && !palette.can_encode?
+        if color_mode == ChunkyPNG::COLOR_INDEXED && (encoding_palette.nil? || !encoding_palette.can_encode?)
           raise "This palette is not suitable for encoding!"
         end
 
-        pixel_size = Color.bytesize(color_mode)
-        pixel_encoder = case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR       then TRUECOLOR_ENCODER
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then TRUECOLOR_ALPHA_ENCODER
-          when ChunkyPNG::COLOR_GRAYSCALE       then GRAYSCALE_ENCODER
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then GRAYSCALE_ALPHA_ENCODER
-          when ChunkyPNG::COLOR_INDEXED         then lambda { |color| [palette.index(color)] }
-          else raise "Cannot encode pixels for this mode: #{color_mode}!"
-        end
-
         case interlace
-          when ChunkyPNG::INTERLACING_NONE  then encode_png_image_without_interlacing(pixel_size, pixel_encoder)
-          when ChunkyPNG::INTERLACING_ADAM7 then encode_png_image_with_interlacing(pixel_size, pixel_encoder)
+          when ChunkyPNG::INTERLACING_NONE  then encode_png_image_without_interlacing(color_mode)
+          when ChunkyPNG::INTERLACING_ADAM7 then encode_png_image_with_interlacing(color_mode)
           else raise "Unknown interlacing method!"
         end
       end
 
-      def encode_png_image_without_interlacing(pixel_size, pixel_encoder)
+      def encode_png_image_without_interlacing(color_mode)
         stream = ""
-        encode_png_image_pass_to_stream(stream, pixel_size, pixel_encoder)
+        encode_png_image_pass_to_stream(stream, color_mode)
         stream
       end
       
-      def encode_png_image_with_interlacing(pixel_size, pixel_encoder)
+      def encode_png_image_with_interlacing(color_mode)
         stream = ""
         0.upto(6) do |pass|
           subcanvas = self.class.adam7_extract_pass(pass, self)
-          subcanvas.encode_png_image_pass_to_stream(stream, pixel_size, pixel_encoder)
+          subcanvas.encoding_palette = encoding_palette
+          subcanvas.encode_png_image_pass_to_stream(stream, color_mode)
         end
         stream
       end
       
-      def encode_png_image_pass_to_stream(stream, pixel_size, pixel_encoder)
-        case pixel_encoder
-          when TRUECOLOR_ALPHA_ENCODER
+      def encode_png_image_pass_to_stream(stream, color_mode)
+
+        case color_mode
+          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA
             stream << pixels.pack("xN#{width}" * height)
-          when TRUECOLOR_ENCODER 
+            
+          when ChunkyPNG::COLOR_TRUECOLOR 
             line_packer = 'x' + ('NX' * width)
             stream << pixels.pack(line_packer * height)
+            
           else
+            
+            pixel_size = Color.bytesize(color_mode)
+            pixel_encoder = case color_mode
+              when ChunkyPNG::COLOR_TRUECOLOR       then lambda { |color| Color.to_truecolor_bytes(color) }
+              when ChunkyPNG::COLOR_TRUECOLOR_ALPHA then lambda { |color| Color.to_truecolor_alpha_bytes(color) }
+              when ChunkyPNG::COLOR_INDEXED         then lambda { |color| [encoding_palette.index(color)] }
+              when ChunkyPNG::COLOR_GRAYSCALE       then lambda { |color| Color.to_grayscale_bytes(color) }
+              when ChunkyPNG::COLOR_GRAYSCALE_ALPHA then lambda { |color| Color.to_grayscale_alpha_bytes(color) }
+              else raise "Cannot encode pixels for this mode: #{color_mode}!"
+            end
+
             previous_bytes = Array.new(pixel_size * width, 0)
             each_scanline do |line|
               unencoded_bytes = line.map(&pixel_encoder).flatten
@@ -183,7 +187,7 @@ module ChunkyPNG
         for index in 0...original_bytes.length do
           a = (index >= pixelsize) ? original_bytes[index - pixelsize] : 0
           b = previous_bytes[index]
-          encoded_bytes[index] = (original_bytes[index] - (a + b / 2).floor) % 256
+          encoded_bytes[index] = (original_bytes[index] - ((a + b) >> 1)) % 256
         end
         [ChunkyPNG::FILTER_AVERAGE] + encoded_bytes
       end

data/lib/chunky_png/color.rb

@@ -31,20 +31,20 @@ module ChunkyPNG
 
     # Creates a new color using an r, g, b triple.
     # @return [Fixnum] The newly constructed color value.
-    def rgb(r, g, b, a = MAX)
-      rgba(r, g, b, a)
+    def rgb(r, g, b)
+      r << 24 | g << 16 | b << 8 | 0xff
     end
 
     # Creates a new color using a grayscale teint.
     # @return [ChunkyPNG::Color] The newly constructed color value.
-    def grayscale(teint, a = MAX)
-      rgba(teint, teint, teint, a)
+    def grayscale(teint)
+      teint << 24 | teint << 16 | teint << 8 | 0xff
     end
 
     # Creates a new color using a grayscale teint and alpha value.
     # @return [Fixnum] The newly constructed color value.
     def grayscale_alpha(teint, a)
-      rgba(teint, teint, teint, a)
+      teint << 24 | teint << 16 | teint << 8 | a
     end
     
     ####################################################################

data/spec/chunky_png/canvas/png_decoding_spec.rb

@@ -43,7 +43,7 @@ describe ChunkyPNG::Canvas::PNGDecoding do
     
     it "should decode a line with average filtering correctly" do
       previous = [10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
-      current  = [ 0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
+      current  = [ 0,  0, 10, 23, 15, 13, 23, 63, 38,  60, 253,  53]
       decoded  = decode_png_scanline(ChunkyPNG::FILTER_AVERAGE, current, previous)
       decoded.should == [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
     end

data/spec/chunky_png/canvas/png_encoding_spec.rb

@@ -57,7 +57,7 @@ describe ChunkyPNG::Canvas::PNGEncoding do
       previous = [10, 20, 30, 40, 50, 60, 70, 80,   80, 100, 110, 120]
       current  = [ 5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
       encoded  = encode_png_scanline(ChunkyPNG::FILTER_AVERAGE, current, previous)
-      encoded.should == [3, 0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
+      encoded.should == [3, 0, 0, 10, 23, 15, 13, 23, 63, 38, 60, 253, 53]
     end
     
     it "should encode a scanline with paeth filtering correctly" do

data/spec/chunky_png/canvas_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe ChunkyPNG::Canvas do
 
   describe '.from_rgb_stream' do
-    it "should load an image correctly from a datastrean" do
+    it "should load an image correctly from a datastream" do
       File.open(resource_file('pixelstream.rgb')) do |stream|
         matrix = ChunkyPNG::Canvas.from_rgb_stream(240, 180, stream)
         matrix.should == reference_canvas('pixelstream_reference')
@@ -12,7 +12,7 @@ describe ChunkyPNG::Canvas do
   end
 
   describe '.from_rgba_stream' do
-    it "should load an image correctly from a datastrean" do
+    it "should load an image correctly from a datastream" do
       File.open(resource_file('pixelstream.rgba')) do |stream|
         matrix = ChunkyPNG::Canvas.from_rgba_stream(240, 180, stream)
         matrix.should == reference_canvas('pixelstream_reference')
@@ -21,16 +21,24 @@ describe ChunkyPNG::Canvas do
   end
   
   describe '#to_rgba_stream' do
-    it "should load an image correctly from a datastrean" do
+    before (:each) do
+      File.open(resource_file('pixelstream.rgba'), 'rb') { |f| @reference_data = f.read }
+    end
+    
+    it "should load an image correctly from a datastream" do
       canvas = reference_canvas('pixelstream_reference')
-      canvas.to_rgba_stream.should == File.read(resource_file('pixelstream.rgba'))
+      canvas.to_rgba_stream.should == @reference_data
     end
   end
 
   describe '#to_rgb_stream' do
-    it "should load an image correctly from a datastrean" do
+    before (:each) do
+      File.open(resource_file('pixelstream.rgb'), 'rb') { |f| @reference_data = f.read }
+    end
+    
+    it "should load an image correctly from a datastream" do
       canvas = reference_canvas('pixelstream_reference')
-      canvas.to_rgb_stream.should == File.read(resource_file('pixelstream.rgb'))
+      canvas.to_rgb_stream.should == @reference_data
     end
   end
 

data/spec/chunky_png/rmagick_spec.rb

@@ -13,9 +13,7 @@ describe ChunkyPNG::RMagick do
   it "should export an image to RMagick correctly" do
     canvas = reference_canvas('16x16_non_interlaced')
     image  = ChunkyPNG::RMagick.export(canvas)
-  
-    filename = resource_file('_rmagick.png')
-    image.write("png:#{filename}") { |info| info.depth = 8 }
-    canvas.should == ChunkyPNG::Canvas.from_file(filename)
+    image.format = 'PNG32'
+    canvas.should == ChunkyPNG::Canvas.from_blob(image.to_blob)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: chunky_png
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors: 
 - Willem van Bergen