chunky_png 0.11.1 → 0.12.0

data/.infinity_test

@@ -1,3 +1,8 @@
 infinity_test do
+  
   use :rubies => %w(1.8.7 1.9.2 ree jruby rbx), :test_framework => :rspec
+  
+  before(:each_ruby) do |environment|
+    environment.system('bundle install')
+  end
 end

data/Gemfile

@@ -1,2 +1,6 @@
 source :rubygems
 gemspec
+
+platforms :jruby do
+  gem 'jruby-openssl'
+end

data/Gemfile.lock

@@ -1,21 +1,24 @@
 PATH
   remote: .
   specs:
-    chunky_png (0.11.1)
+    chunky_png (0.12.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
+    bouncy-castle-java (1.5.0145.2)
     diff-lcs (1.1.2)
+    jruby-openssl (0.7.2)
+      bouncy-castle-java
     rake (0.8.7)
-    rspec (2.1.0)
-      rspec-core (~> 2.1.0)
-      rspec-expectations (~> 2.1.0)
-      rspec-mocks (~> 2.1.0)
-    rspec-core (2.1.0)
-    rspec-expectations (2.1.0)
+    rspec (2.2.0)
+      rspec-core (~> 2.2)
+      rspec-expectations (~> 2.2)
+      rspec-mocks (~> 2.2)
+    rspec-core (2.2.1)
+    rspec-expectations (2.2.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.1.0)
+    rspec-mocks (2.2.0)
 
 PLATFORMS
   java
@@ -23,5 +26,6 @@ PLATFORMS
 
 DEPENDENCIES
   chunky_png!
+  jruby-openssl
   rake
-  rspec (~> 2.1)
+  rspec (~> 2.2)

data/chunky_png.gemspec

@@ -3,8 +3,8 @@ 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.11.1"
-  s.date    = "2010-11-16"
+  s.version = "0.12.0"
+  s.date    = "2010-12-12"
 
   s.summary     = "Pure ruby library for read/write, chunk-level access to PNG files"
   s.description = <<-EOT
@@ -31,7 +31,7 @@ Gem::Specification.new do |s|
   s.homepage = 'http://wiki.github.com/wvanbergen/chunky_png'
 
   s.add_development_dependency('rake')
-  s.add_development_dependency('rspec', '~> 2.1')
+  s.add_development_dependency('rspec', '~> 2.2')
 
   s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
   s.extra_rdoc_files = ['README.rdoc', 'BENCHMARKS.rdoc']

data/lib/chunky_png.rb

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

data/lib/chunky_png/canvas/png_encoding.rb

@@ -64,20 +64,23 @@ module ChunkyPNG
       # @option constraints [true, false] :interlace Whether to use interlacing.
       # @option constraints [Fixnum] :compression The compression level for Zlib. This can be a
       #    value between 0 and 9, or a Zlib constant like Zlib::BEST_COMPRESSION.
+      # @option constraints [Fixnum] :bit_depth The bit depth to use. This option is only used
+      #    for indexed images, in which case it overrides the determined minimal bit depth. For
+      #    all the other color modes, a bit depth of 8 is used.
       # @return [ChunkyPNG::Datastream] The PNG datastream containing the encoded canvas.
       # @see ChunkyPNG::Canvas::PNGEncoding#determine_png_encoding
       def to_datastream(constraints = {})
         encoding = determine_png_encoding(constraints)
 
         ds = Datastream.new
-        ds.header_chunk = Chunk::Header.new(:width => width, :height => height, 
-            :color => encoding[:color_mode], :interlace => encoding[:interlace])
+        ds.header_chunk = Chunk::Header.new(:width => width, :height => height,
+            :color => encoding[:color_mode], :depth => encoding[:bit_depth], :interlace => encoding[:interlace])
 
         if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
           ds.palette_chunk      = encoding_palette.to_plte_chunk
           ds.transparency_chunk = encoding_palette.to_trns_chunk unless encoding_palette.opaque?
         end
-        data           = encode_png_pixelstream(encoding[:color_mode], encoding[:interlace], encoding[:filtering])
+        data           = encode_png_pixelstream(encoding[:color_mode], encoding[:bit_depth], encoding[:interlace], encoding[:filtering])
         ds.data_chunks = Chunk::ImageData.split_in_chunks(data, encoding[:compression])
         ds.end_chunk   = Chunk::End.new
         return ds
@@ -119,6 +122,14 @@ module ChunkyPNG
           self.encoding_palette = self.palette
           encoding[:color_mode] ||= encoding_palette.best_colormode
         end
+        
+        # Set the number of bits per color channel. This will always be 8 except for
+        # indexed image, which may also use lower bit depths
+        if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
+          encoding[:bit_depth] = [encoding_palette.determine_bit_depth, encoding[:bit_depth] || 1].max
+        else
+          encoding[:bit_depth] = 8
+        end
 
         # Use Zlib's default for compression unless otherwise provided.
         encoding[:compression] ||= Zlib::DEFAULT_COMPRESSION
@@ -140,28 +151,30 @@ module ChunkyPNG
       # Encodes the canvas according to the PNG format specification with a given color 
       # mode, possibly with interlacing.
       # @param [Integer] color_mode The color mode to use for encoding.
+      # @param [Integer] bit_depth The bit depth of the image.
       # @param [Integer] interlace The interlacing method to use.
       # @return [String] The PNG encoded canvas as string.
-      def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, interlace = ChunkyPNG::INTERLACING_NONE, filtering = ChunkyPNG::FILTER_NONE)
+      def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, bit_depth = 8, interlace = ChunkyPNG::INTERLACING_NONE, filtering = ChunkyPNG::FILTER_NONE)
 
         if color_mode == ChunkyPNG::COLOR_INDEXED && (encoding_palette.nil? || !encoding_palette.can_encode?)
           raise ChunkyPNG::ExpectationFailed, "This palette is not suitable for encoding!"
         end
 
         case interlace
-          when ChunkyPNG::INTERLACING_NONE;  encode_png_image_without_interlacing(color_mode, filtering)
-          when ChunkyPNG::INTERLACING_ADAM7; encode_png_image_with_interlacing(color_mode, filtering)
+          when ChunkyPNG::INTERLACING_NONE;  encode_png_image_without_interlacing(color_mode, bit_depth, filtering)
+          when ChunkyPNG::INTERLACING_ADAM7; encode_png_image_with_interlacing(color_mode, bit_depth, filtering)
           else raise ChunkyPNG::NotSupported, "Unknown interlacing method: #{interlace}!"
         end
       end
 
       # Encodes the canvas according to the PNG format specification with a given color mode.
       # @param [Integer] color_mode The color mode to use for encoding.
+      # @param [Integer] bit_depth The bit depth of the image.
       # @param [Integer] filtering The filtering method to use.
       # @return [String] The PNG encoded canvas as string.
-      def encode_png_image_without_interlacing(color_mode, filtering = ChunkyPNG::FILTER_NONE)
+      def encode_png_image_without_interlacing(color_mode, bit_depth = 8, filtering = ChunkyPNG::FILTER_NONE)
         stream = ChunkyPNG::Datastream.empty_bytearray
-        encode_png_image_pass_to_stream(stream, color_mode, filtering)
+        encode_png_image_pass_to_stream(stream, color_mode, bit_depth, filtering)
         stream
       end
 
@@ -172,14 +185,15 @@ module ChunkyPNG
       # one by one, concatenating the resulting strings.
       #
       # @param [Integer] color_mode The color mode to use for encoding.
+      # @param [Integer] bit_depth The bit depth of the image.
       # @param [Integer] filtering The filtering method to use.
       # @return [String] The PNG encoded canvas as string.
-      def encode_png_image_with_interlacing(color_mode, filtering = ChunkyPNG::FILTER_NONE)
+      def encode_png_image_with_interlacing(color_mode, bit_depth = 8, filtering = ChunkyPNG::FILTER_NONE)
         stream = ChunkyPNG::Datastream.empty_bytearray
         0.upto(6) do |pass|
           subcanvas = self.class.adam7_extract_pass(pass, self)
           subcanvas.encoding_palette = encoding_palette
-          subcanvas.encode_png_image_pass_to_stream(stream, color_mode, filtering)
+          subcanvas.encode_png_image_pass_to_stream(stream, color_mode, bit_depth, filtering)
         end
         stream
       end
@@ -187,24 +201,16 @@ module ChunkyPNG
       # Encodes the canvas to a stream, in a given color mode.
       # @param [String] stream The stream to write to.
       # @param [Integer] color_mode The color mode to use for encoding.
+      # @param [Integer] bit_depth The bit depth of the image.
       # @param [Integer] filtering The filtering method to use.
-      def encode_png_image_pass_to_stream(stream, color_mode, filtering)
+      def encode_png_image_pass_to_stream(stream, color_mode, bit_depth, filtering)
 
         start_pos  = stream.bytesize
         pixel_size = Color.pixel_bytesize(color_mode)
-        line_width = pixel_size * width
-        
-        # Encode the whole image without filtering
-        stream << case color_mode
-          when ChunkyPNG::COLOR_TRUECOLOR; pixels.pack(('x' + ('NX' * width)) * height)
-          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; pixels.pack("xN#{width}" * height)
-          when ChunkyPNG::COLOR_INDEXED; pixels.map { |p| encoding_palette.index(p) }.pack("xC#{width}" * height)
-          when ChunkyPNG::COLOR_GRAYSCALE; pixels.map { |p| p >> 8 }.pack("xC#{width}" * height)
-          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; pixels.pack("xn#{width}" * height)
-          else raise ChunkyPNG::NotSupported, "Cannot encode pixels for this mode: #{color_mode}!"
-        end
+        line_width = Color.scanline_bytesize(color_mode, bit_depth, width)
         
         # Determine the filter method
+        encode_method = encode_png_pixels_to_scanline_method(color_mode, bit_depth)
         filter_method = case filtering
           when ChunkyPNG::FILTER_SUB;     :encode_png_str_scanline_sub
           when ChunkyPNG::FILTER_UP;      :encode_png_str_scanline_up
@@ -213,6 +219,10 @@ module ChunkyPNG
           else nil
         end
         
+        0.upto(height - 1) do |y|
+          stream << send(encode_method, row(y))
+        end
+        
         # Now, apply filtering if any
         if filter_method
           (height - 1).downto(0) do |y|
@@ -222,6 +232,106 @@ module ChunkyPNG
           end
         end
       end
+      
+      # Encodes a line of pixels using 8-bit truecolor mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_truecolor_8bit(pixels)
+        pixels.pack('x' + ('NX' * width))
+      end
+      
+      # Encodes a line of pixels using 8-bit truecolor alpha mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_truecolor_alpha_8bit(pixels)
+        pixels.pack("xN#{width}")
+      end
+
+      # Encodes a line of pixels using 1-bit indexed mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_indexed_1bit(pixels)
+        chars = []
+        pixels.each_slice(8) do |p1, p2, p3, p4, p5, p6, p7, p8|
+          chars << ((encoding_palette.index(p1) << 7) |
+                    (encoding_palette.index(p2) << 6) |
+                    (encoding_palette.index(p3) << 5) |
+                    (encoding_palette.index(p4) << 4) |
+                    (encoding_palette.index(p5) << 3) |
+                    (encoding_palette.index(p6) << 2) |
+                    (encoding_palette.index(p7) << 1) |
+                    (encoding_palette.index(p8)))
+        end
+        chars.pack('xC*')
+      end
+      
+      # Encodes a line of pixels using 2-bit indexed mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string      
+      def encode_png_pixels_to_scanline_indexed_2bit(pixels)
+        chars = []
+        pixels.each_slice(4) do |p1, p2, p3, p4|
+          chars << ((encoding_palette.index(p1) << 6) |
+                    (encoding_palette.index(p2) << 4) |
+                    (encoding_palette.index(p3) << 2) |
+                    (encoding_palette.index(p4)))
+        end
+        chars.pack('xC*')
+      end
+      
+      # Encodes a line of pixels using 4-bit indexed mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_indexed_4bit(pixels)
+        chars = []
+        pixels.each_slice(2) do |p1, p2|
+          chars << ((encoding_palette.index(p1) << 4) | (encoding_palette.index(p2)))
+        end
+        chars.pack('xC*')
+      end
+      
+      # Encodes a line of pixels using 8-bit indexed mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_indexed_8bit(pixels)
+        pixels.map { |p| encoding_palette.index(p) }.pack("xC#{width}")
+      end
+      
+      # Encodes a line of pixels using 8-bit grayscale mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_grayscale_8bit(pixels)
+        pixels.map { |p| p >> 8 }.pack("xC#{width}")
+      end
+
+      # Encodes a line of pixels using 8-bit grayscale alpha mode.
+      # @param [Array<Integer>] pixels A row of pixels of the original image.
+      # @return [String] The encoded scanline as binary string
+      def encode_png_pixels_to_scanline_grayscale_alpha_8bit(pixels)
+        pixels.pack("xn#{width}")
+      end
+      
+      
+      # Returns the method name to use to decode scanlines into pixels.
+      # @param [Integer] color_mode The color mode of the image.
+      # @param [Integer] depth The bit depth of the image.
+      # @return [Symbol] The method name to use for decoding, to be called on the canvas class.
+      # @raise [ChunkyPNG::NotSupported] when the color_mode and/or bit depth is not supported.
+      def encode_png_pixels_to_scanline_method(color_mode, depth)
+        encoder_method = case color_mode
+          when ChunkyPNG::COLOR_TRUECOLOR;       :"encode_png_pixels_to_scanline_truecolor_#{depth}bit"
+          when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; :"encode_png_pixels_to_scanline_truecolor_alpha_#{depth}bit"
+          when ChunkyPNG::COLOR_INDEXED;         :"encode_png_pixels_to_scanline_indexed_#{depth}bit"
+          when ChunkyPNG::COLOR_GRAYSCALE;       :"encode_png_pixels_to_scanline_grayscale_#{depth}bit"
+          when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; :"encode_png_pixels_to_scanline_grayscale_alpha_#{depth}bit"
+          else nil
+        end
+        
+        raise ChunkyPNG::NotSupported, "No encoder found for color mode #{color_mode} and #{depth}-bit depth!" unless respond_to?(encoder_method)
+        encoder_method
+      end
+      
+
 
       # Encodes a scanline of a pixelstream without filtering. This is a no-op.
       # @param [String] stream The pixelstream to work on. This string will be modified.

data/lib/chunky_png/palette.rb

@@ -130,7 +130,7 @@ module ChunkyPNG
     # @return [Integer] The 0-based position of the color in the palette.
     # @see ChunkyPNG::Palette#can_encode?
     def index(color)
-      @encoding_map[color]
+      color.nil? ? 0 : @encoding_map[color]
     end
 
     # Creates a tRNS chunk that corresponds with this palette to store the
@@ -183,5 +183,18 @@ module ChunkyPNG
         ChunkyPNG::COLOR_TRUECOLOR_ALPHA
       end
     end
+    
+    # Determines the minimal bit depth required for an indexed image
+    # @return [Integer] Number of bits per pixel, i.e. 1, 2, 4 or 8, or nil if this
+    #    image cannot be saved as an indexed image.
+    def determine_bit_depth
+      case size
+      when 1..2; 1
+      when 3..4; 2
+      when 5..16; 4
+      when 17..256; 8
+      else nil
+      end
+    end
   end
 end

data/spec/chunky_png/canvas/png_encoding_spec.rb

@@ -19,6 +19,46 @@ describe ChunkyPNG::Canvas::PNGEncoding do
       end
     end
     
+    it "should encode an image with 2 colors using 1-bit indexed color mode" do
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p01.png'))
+      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
+      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
+      ds.header_chunk.depth.should == 1
+      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+    end
+    
+    it "should encode an image with 4 colors using 2-bit indexed color mode" do
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p02.png'))
+      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
+      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
+      ds.header_chunk.depth.should == 2
+      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+    end
+    
+    it "should encode an image with 16 colors using 4-bit indexed color mode" do
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p04.png'))
+      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
+      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
+      ds.header_chunk.depth.should == 4
+      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+    end
+    
+    it "should encode an image with 256 colors using 8-bit indexed color mode" do
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p08.png'))
+      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob)
+      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
+      ds.header_chunk.depth.should == 8
+      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+    end
+    
+    it "should use a higher bit depth than necessary if requested" do
+      @canvas = ChunkyPNG::Canvas.from_file(png_suite_file('basic', 'basn3p01.png'))
+      ds = ChunkyPNG::Datastream.from_blob(@canvas.to_blob(:bit_depth => 4))
+      ds.header_chunk.color.should == ChunkyPNG::COLOR_INDEXED
+      ds.header_chunk.depth.should == 4
+      @canvas.should == ChunkyPNG::Canvas.from_datastream(ds)
+    end
+    
     it "should encode an image with interlacing correctly" do
       input_canvas = ChunkyPNG::Canvas.from_file(resource_file('operations.png'))
       filename = resource_file("_tmp_interlaced.png")
@@ -68,42 +108,65 @@ describe ChunkyPNG::Canvas::PNGEncoding do
   end
 
   describe '#encode_png_image_pass_to_stream' do
-    before { @canvas = ChunkyPNG::Canvas.new(2, 2, ChunkyPNG::Color.rgba(1, 2, 3, 4)) }
+    before do 
+      @canvas = ChunkyPNG::Canvas.new(2, 2, ChunkyPNG::Color.rgba(1, 2, 3, 4))
+      @palette_mock = mock('Palette')
+      @palette_mock.stub(:index).with(ChunkyPNG::Color.rgba(1, 2, 3, 4)).and_return(1)
+      @palette_mock.stub(:index).with(nil).and_return(0)
+    end
 
     it "should encode using RGBA / no filtering mode correctly" do
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, ChunkyPNG::FILTER_NONE)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_NONE)
       stream.should == "\0\1\2\3\4\1\2\3\4\0\1\2\3\4\1\2\3\4"
     end
 
     it "should encode using RGBA / SUB filtering mode correctly" do
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, ChunkyPNG::FILTER_SUB)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_SUB)
       stream.should == "\1\1\2\3\4\0\0\0\0\1\1\2\3\4\0\0\0\0"
     end
 
     it "should encode using RGBA / UP filtering mode correctly" do
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, ChunkyPNG::FILTER_UP)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_UP)
       stream.should == "\2\1\2\3\4\1\2\3\4\2\0\0\0\0\0\0\0\0"
     end
 
     it "should encode using RGBA / AVERAGE filtering mode correctly" do
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, ChunkyPNG::FILTER_AVERAGE)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR_ALPHA, 8, ChunkyPNG::FILTER_AVERAGE)
       stream.should == "\3\1\2\3\4\1\1\2\2\3\1\1\2\2\0\0\0\0"
     end
 
     it "should encode using RGB / no filtering mode correctly" do
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, ChunkyPNG::FILTER_NONE)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_TRUECOLOR, 8, ChunkyPNG::FILTER_NONE)
       stream.should == "\0\1\2\3\1\2\3\0\1\2\3\1\2\3"
     end
 
     it "should encode using indexed / no filtering mode correctly" do
-      @canvas.stub(:encoding_palette).and_return(mock('Palette', :index => 1))
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, ChunkyPNG::FILTER_NONE)
+      @canvas.stub(:encoding_palette).and_return(@palette_mock)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::FILTER_NONE)
       stream.should == "\0\1\1\0\1\1"
     end
+    
+    it "should encode using 1-bit indexed / no filtering mode correctly" do
+      @canvas.stub(:encoding_palette).and_return(@palette_mock)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 1, ChunkyPNG::FILTER_NONE)
+      stream.should == "\0\xc0\0\xc0"
+    end
+    
+    it "should encode using 2-bit indexed / no filtering mode correctly" do
+      @canvas.stub(:encoding_palette).and_return(@palette_mock)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 2, ChunkyPNG::FILTER_NONE)
+      stream.should == "\x00\x50\x00\x50"
+    end
+    
+    it "should encode using 4-bit indexed / no filtering mode correctly" do
+      @canvas.stub(:encoding_palette).and_return(@palette_mock)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 4, ChunkyPNG::FILTER_NONE)
+      stream.should == "\0\x11\0\x11"
+    end
 
     it "should encode using indexed / PAETH filtering mode correctly" do
-      @canvas.stub(:encoding_palette).and_return(mock('Palette', :index => 1))
-      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, ChunkyPNG::FILTER_PAETH)
+      @canvas.stub(:encoding_palette).and_return(@palette_mock)
+      @canvas.encode_png_image_pass_to_stream(stream = ChunkyPNG::Datastream.empty_bytearray, ChunkyPNG::COLOR_INDEXED, 8, ChunkyPNG::FILTER_PAETH)
       stream.should == "\4\1\0\4\0\0"
     end
   end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 11
-  - 1
-  version: 0.11.1
+  - 12
+  - 0
+  version: 0.12.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-16 00:00:00 -05:00
+date: 2010-12-12 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,8 +39,8 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 2
-        - 1
-        version: "2.1"
+        - 2
+        version: "2.2"
   type: :development
   prerelease: false
   version_requirements: *id002
@@ -360,7 +360,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3047594374404254656
+      hash: 1966366750719945677
       segments: 
       - 0
       version: "0"
@@ -369,7 +369,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3047594374404254656
+      hash: 1966366750719945677
       segments: 
       - 0
       version: "0"