chunky_png 0.9.2 → 0.10.0

data/lib/chunky_png/canvas/png_encoding.rb

@@ -6,9 +6,9 @@ module ChunkyPNG
     # Overview of the encoding process:
     #
     # * The image is split up in scanlines (i.e. rows of pixels);
-    # * Every pixel in this row is converted into bytes, based on the color mode;
-    # * Filter every byte in the row according to the filter method.
-    # * Concatenate all the filtered bytes of every line to a single stream
+    # * All pixels are encoded as a pixelstream, based on the color mode.
+    # * All the pixel bytes in the pixelstream are adjusted using a filtering 
+    #   method if one is specified.
     # * Compress the resulting string using deflate compression.
     # * Split compressed data over one or more PNG chunks.
     # * These chunks should be embedded in a datastream with at least a IHDR and 
@@ -48,17 +48,17 @@ module ChunkyPNG
         to_datastream(constraints).to_blob
       end
       
-      alias :to_string :to_blob
-      alias :to_s :to_blob
+      alias_method :to_string, :to_blob
+      alias_method :to_s, :to_blob
 
       # Converts this Canvas to a datastream, so that it can be saved as a PNG image.
       # @param [Hash, Symbol] constraints The constraints to use when encoding the canvas.
       #    This can either be a hash with different constraints, or a symbol which acts as a 
       #    preset for some constraints. If no constraints are given, ChunkyPNG will decide  
       #    for itself how to best create the PNG datastream. 
-      #    Supported presets are :fast_rgba for quickly saving images with transparency,
-      #    :fast_rgb for quickly saving opaque images, and :best_compression to obtain the
-      #    smallest possible filesize.
+      #    Supported presets are <tt>:fast_rgba</tt> for quickly saving images with transparency,
+      #    <tt>:fast_rgb</tt> for quickly saving opaque images, and <tt>:best_compression</tt> to
+      #    obtain the smallest possible filesize.
       # @option constraints [Fixnum] :color_mode The color mode to use. Use one of the 
       #    ChunkyPNG::COLOR_* constants.
       # @option constraints [true, false] :interlace Whether to use interlacing.
@@ -68,17 +68,16 @@ module ChunkyPNG
       # @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])
-        
+
         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[:compression])
+        data           = encode_png_pixelstream(encoding[:color_mode], encoding[:interlace], encoding[:filtering])
         ds.data_chunks = Chunk::ImageData.split_in_chunks(data, encoding[:compression])
         ds.end_chunk   = Chunk::End.new
         return ds
@@ -96,17 +95,21 @@ module ChunkyPNG
       #    Hash or a preset symbol.
       # @return [Hash] A hash with encoding options for {ChunkyPNG::Canvas::PNGEncoding#to_datastream}
       def determine_png_encoding(constraints = {})
-        
+
         if constraints == :fast_rgb
           encoding = { :color_mode => ChunkyPNG::COLOR_TRUECOLOR, :compression => Zlib::BEST_SPEED }
         elsif constraints == :fast_rgba
           encoding = { :color_mode => ChunkyPNG::COLOR_TRUECOLOR_ALPHA, :compression => Zlib::BEST_SPEED }
         elsif constraints == :best_compression
-          encoding = { :compression => Zlib::BEST_COMPRESSION }
+          encoding = { :compression => Zlib::BEST_COMPRESSION, :filtering => ChunkyPNG::FILTER_PAETH }
+        elsif constraints == :good_compression
+          encoding = { :compression => Zlib::BEST_COMPRESSION, :filtering => ChunkyPNG::FILTER_NONE }
+        elsif constraints == :no_compression
+          encoding = { :compression => Zlib::NO_COMPRESSION }
         else
           encoding = constraints
         end
-        
+
         # Do not create a pallete when the encoding is given and does not require a palette.
         if encoding[:color_mode]
           if encoding[:color_mode] == ChunkyPNG::COLOR_INDEXED
@@ -116,47 +119,52 @@ module ChunkyPNG
           self.encoding_palette = self.palette
           encoding[:color_mode] ||= encoding_palette.best_colormode
         end
-        
+
+        # Use Zlib's default for compression unless otherwise provided.
         encoding[:compression] ||= Zlib::DEFAULT_COMPRESSION
-        
+
         encoding[:interlace] = case encoding[:interlace]
-          when nil, false, ChunkyPNG::INTERLACING_NONE then ChunkyPNG::INTERLACING_NONE
-          when true, ChunkyPNG::INTERLACING_ADAM7      then ChunkyPNG::INTERLACING_ADAM7
+          when nil, false, ChunkyPNG::INTERLACING_NONE; ChunkyPNG::INTERLACING_NONE
+          when true, ChunkyPNG::INTERLACING_ADAM7;      ChunkyPNG::INTERLACING_ADAM7
           else encoding[:interlace]
         end
 
+        encoding[:filtering] ||= case encoding[:compression]
+          when Zlib::BEST_COMPRESSION; ChunkyPNG::FILTER_PAETH
+          when Zlib::NO_COMPRESSION..Zlib::BEST_SPEED; ChunkyPNG::FILTER_NONE
+          else ChunkyPNG::FILTER_UP
+        end
         return encoding
       end
-      
+
       # 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] interlace The interlacing method to use.
-      # @param [Integer] compression The Zlib compression level.
       # @return [String] The PNG encoded canvas as string.
-      def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, interlace = ChunkyPNG::INTERLACING_NONE, compression = ZLib::DEFAULT_COMPRESSION)
+      def encode_png_pixelstream(color_mode = ChunkyPNG::COLOR_TRUECOLOR, 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  then encode_png_image_without_interlacing(color_mode, compression)
-          when ChunkyPNG::INTERLACING_ADAM7 then encode_png_image_with_interlacing(color_mode, compression)
+          when ChunkyPNG::INTERLACING_NONE  then encode_png_image_without_interlacing(color_mode, filtering)
+          when ChunkyPNG::INTERLACING_ADAM7 then encode_png_image_with_interlacing(color_mode, 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] compression The Zlib compression level.
+      # @param [Integer] filtering The filtering method to use.
       # @return [String] The PNG encoded canvas as string.
-      def encode_png_image_without_interlacing(color_mode, compression = ZLib::DEFAULT_COMPRESSION)
+      def encode_png_image_without_interlacing(color_mode, filtering = ChunkyPNG::FILTER_NONE)
         stream = ""
-        encode_png_image_pass_to_stream(stream, color_mode, compression)
+        encode_png_image_pass_to_stream(stream, color_mode, filtering)
         stream
       end
-      
+
       # Encodes the canvas according to the PNG format specification with a given color 
       # mode and Adam7 interlacing.
       #
@@ -164,141 +172,121 @@ module ChunkyPNG
       # one by one, concatenating the resulting strings.
       #
       # @param [Integer] color_mode The color mode to use for encoding.
-      # @param [Integer] compression The Zlib compression level.
+      # @param [Integer] filtering The filtering method to use.
       # @return [String] The PNG encoded canvas as string.
-      def encode_png_image_with_interlacing(color_mode, compression = ZLib::DEFAULT_COMPRESSION)
+      def encode_png_image_with_interlacing(color_mode, filtering = ChunkyPNG::FILTER_NONE)
         stream = ""
         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, compression)
+          subcanvas.encode_png_image_pass_to_stream(stream, color_mode, filtering)
         end
         stream
       end
-      
+
       # Encodes the canvas to a stream, in a given color mode.
-      # @param [String, IO, :<<] stream The stream to write to.
+      # @param [String] stream The stream to write to.
       # @param [Integer] color_mode The color mode to use for encoding.
-      # @param [Integer] compression The Zlib compression level.
-      def encode_png_image_pass_to_stream(stream, color_mode, compression = ZLib::DEFAULT_COMPRESSION)
+      # @param [Integer] filtering The filtering method to use.
+      def encode_png_image_pass_to_stream(stream, color_mode, filtering = ChunkyPNG::FILTER_NONE)
 
-        if compression < Zlib::BEST_COMPRESSION && color_mode == ChunkyPNG::COLOR_TRUECOLOR_ALPHA
-          # Fast RGBA saving routine
-          stream << pixels.pack("xN#{width}" * height)
-          
-        elsif compression < Zlib::BEST_COMPRESSION && color_mode == ChunkyPNG::COLOR_TRUECOLOR
-          # Fast RGB saving routine
-          line_packer = 'x' + ('NX' * width)
-          stream << pixels.pack(line_packer * height)
-          
-        else
-          # Normal saving routine
-          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 ChunkyPNG::NotSupported, "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
-            stream << encode_png_scanline_paeth(unencoded_bytes, previous_bytes, pixel_size).pack('C*')
-            previous_bytes = unencoded_bytes
-          end
+        start_pos  = stream.bytesize
+        pixel_size = Color.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
-      end
-
-      # Passes to this canvas of pixel values line by line.
-      # @yield [line] Yields the scanlines of this image one by one.
-      # @yieldparam [Array<Integer>] line An line of fixnums representing pixels
-      def each_scanline(&block)
-        for line_no in 0...height do
-          scanline = pixels[width * line_no, width]
-          yield(scanline)
+        
+        # Determine the filter method
+        filter_method = case filtering
+          when ChunkyPNG::FILTER_SUB;     :encode_png_str_scanline_sub
+          when ChunkyPNG::FILTER_UP;      :encode_png_str_scanline_up
+          when ChunkyPNG::FILTER_AVERAGE; :encode_png_str_scanline_average
+          when ChunkyPNG::FILTER_PAETH;   :encode_png_str_scanline_paeth
+          else nil
         end
-      end
-
-      # Encodes the bytes of a scanline with a given filter.
-      # @param [Integer] filter The filter method to use.
-      # @param [Array<Integer>]  bytes The scanline bytes to encode.
-      # @param [Array<Integer>]  previous_bytes The original bytes of the previous scanline.
-      # @param [Integer] pixelsize The number of bytes per pixel.
-      # @return [Array<Integer>] The filtered array of bytes.
-      def encode_png_scanline(filter, bytes, previous_bytes = nil, pixelsize = 3)
-        case filter
-        when ChunkyPNG::FILTER_NONE    then encode_png_scanline_none(    bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_SUB     then encode_png_scanline_sub(     bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_UP      then encode_png_scanline_up(      bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_AVERAGE then encode_png_scanline_average( bytes, previous_bytes, pixelsize)
-        when ChunkyPNG::FILTER_PAETH   then encode_png_scanline_paeth(   bytes, previous_bytes, pixelsize)
-        else raise ChunkyPNG::NotSupported, "Unknown filter type: #{filter}!"
+        
+        # Now, apply filtering if any
+        if filter_method
+          (height - 1).downto(0) do |y|
+            pos = start_pos + y * (line_width + 1)
+            prev_pos = (y == 0) ? nil : pos - (line_width + 1)
+            send(filter_method, stream, pos, prev_pos, line_width, pixel_size)
+          end
         end
       end
 
-      # Encodes the bytes of a scanline without filtering.
-      # @param [Array<Integer>]  bytes The scanline bytes to encode.
-      # @param [Array<Integer>]  previous_bytes The original bytes of the previous scanline.
-      # @param [Integer] pixelsize The number of bytes per pixel.
-      # @return [Array<Integer>] The filtered array of bytes.
-      def encode_png_scanline_none(original_bytes, previous_bytes = nil, pixelsize = 3)
-        [ChunkyPNG::FILTER_NONE] + original_bytes
+      # 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.
+      # @param [Integer] pos The starting position of the scanline.
+      # @param [Integer, nil] prev_pos The starting position of the previous scanline. <tt>nil</tt> if
+      #     this is the first line.
+      # @param [Integer] line_width The number of bytes in this scanline, without counting the filtering
+      #     method byte.
+      # @param [Integer] pixel_size The number of bytes used per pixel.
+      # @return [nil]
+      def encode_png_str_scanline_none(stream, pos, prev_pos, line_width, pixel_size)
+        # noop - this method shouldn't get called at all.
       end
 
-      # Encodes the bytes of a scanline with SUB filtering.
-      # @param (see ChunkyPNG::Canvas::PNGEncoding#encode_png_scanline_none)
-      def encode_png_scanline_sub(original_bytes, previous_bytes = nil, pixelsize = 3)
-        encoded_bytes = []
-        for index in 0...original_bytes.length do
-          a = (index >= pixelsize) ? original_bytes[index - pixelsize] : 0
-          encoded_bytes[index] = (original_bytes[index] - a) % 256
+      # Encodes a scanline of a pixelstream using SUB filtering. This will modify the stream.
+      # @param (see #encode_png_str_scanline_none)
+      # @return [nil]
+      def encode_png_str_scanline_sub(stream, pos, prev_pos, line_width, pixel_size)
+        line_width.downto(1) do |i|
+          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
+          stream.setbyte(pos + i, (stream.getbyte(pos + i) - a) & 0xff)
         end
-        [ChunkyPNG::FILTER_SUB] + encoded_bytes
+        stream.setbyte(pos, ChunkyPNG::FILTER_SUB)
       end
 
-      # Encodes the bytes of a scanline with UP filtering.
-      # @param (see ChunkyPNG::Canvas::PNGEncoding#encode_png_scanline_none)
-      def encode_png_scanline_up(original_bytes, previous_bytes, pixelsize = 3)
-        encoded_bytes = []
-        for index in 0...original_bytes.length do
-          b = previous_bytes[index]
-          encoded_bytes[index] = (original_bytes[index] - b) % 256
+      # Encodes a scanline of a pixelstream using UP filtering. This will modify the stream.
+      # @param (see #encode_png_str_scanline_none)
+      # @return [nil]
+      def encode_png_str_scanline_up(stream, pos, prev_pos, line_width, pixel_size)
+        line_width.downto(1) do |i|
+          b = prev_pos ? stream.getbyte(prev_pos + i) : 0
+          stream.setbyte(pos + i, (stream.getbyte(pos + i) - b) & 0xff)
         end
-        [ChunkyPNG::FILTER_UP] + encoded_bytes
+        stream.setbyte(pos, ChunkyPNG::FILTER_UP)
       end
-
-      # Encodes the bytes of a scanline with AVERAGE filtering.
-      # @param (see ChunkyPNG::Canvas::PNGEncoding#encode_png_scanline_none)
-      def encode_png_scanline_average(original_bytes, previous_bytes, pixelsize = 3)
-        encoded_bytes = []
-        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) >> 1)) % 256
+      
+      # Encodes a scanline of a pixelstream using AVERAGE filtering. This will modify the stream.
+      # @param (see #encode_png_str_scanline_none)
+      # @return [nil]
+      def encode_png_str_scanline_average(stream, pos, prev_pos, line_width, pixel_size)
+        line_width.downto(1) do |i|
+          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
+          b = prev_pos ? stream.getbyte(prev_pos + i) : 0
+          stream.setbyte(pos + i, (stream.getbyte(pos + i) - ((a + b) >> 1)) & 0xff)
         end
-        [ChunkyPNG::FILTER_AVERAGE] + encoded_bytes
+        stream.setbyte(pos, ChunkyPNG::FILTER_AVERAGE)
       end
-
-      # Encodes the bytes of a scanline with PAETH filtering.
-      # @param (see ChunkyPNG::Canvas::PNGEncoding#encode_png_scanline_none)
-      def encode_png_scanline_paeth(original_bytes, previous_bytes, pixelsize = 3)
-        encoded_bytes = []
-        for i in 0...original_bytes.length do
-          a = (i >= pixelsize) ? original_bytes[i - pixelsize] : 0
-          b = previous_bytes[i]
-          c = (i >= pixelsize) ? previous_bytes[i - pixelsize] : 0
+      
+      # Encodes a scanline of a pixelstream using PAETH filtering. This will modify the stream.
+      # @param (see #encode_png_str_scanline_none)
+      # @return [nil]
+      def encode_png_str_scanline_paeth(stream, pos, prev_pos, line_width, pixel_size)
+        line_width.downto(1) do |i|
+          a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0
+          b = (prev_pos) ? stream.getbyte(prev_pos + i) : 0
+          c = (prev_pos && i > pixel_size) ? stream.getbyte(prev_pos + i - pixel_size) : 0
           p = a + b - c
           pa = (p - a).abs
           pb = (p - b).abs
           pc = (p - c).abs
           pr = (pa <= pb && pa <= pc) ? a : (pb <= pc ? b : c)
-          encoded_bytes[i] = (original_bytes[i] - pr) % 256
+          stream.setbyte(pos + i, (stream.getbyte(pos + i) - pr) & 0xff)
         end
-        [ChunkyPNG::FILTER_PAETH] + encoded_bytes
-      end
+        stream.setbyte(pos, ChunkyPNG::FILTER_PAETH)
+      end      
     end
   end
 end

data/lib/chunky_png/canvas/stream_importing.rb

@@ -17,7 +17,7 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_rgb_stream(width, height, stream)
         string = stream.respond_to?(:read) ? stream.read(3 * width * height) : stream.to_s[0, 3 * width * height]
-        string << "\255" # Add a fourth byte to the last RGB triple.
+        string << ChunkyPNG::EXTRA_BYTE # Add a fourth byte to the last RGB triple.
         unpacker = 'NX' * (width * height)
         pixels = string.unpack(unpacker).map { |color| color | 0x000000ff }
         self.new(width, height, pixels)
@@ -51,7 +51,7 @@ module ChunkyPNG
       # @param [#read, String] stream The stream to read the pixel data from.
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_bgr_stream(width, height, stream)
-        string = "\255" # Add a first byte to the first BGR triple.
+        string = ChunkyPNG::EXTRA_BYTE # Add a first byte to the first BGR triple.
         string << stream.respond_to?(:read) ? stream.read(3 * width * height) : stream.to_s[0, 3 * width * height]
         pixels = string.unpack("@1" << ('XV' * (width * height))).map { |color| color | 0x000000ff }
         self.new(width, height, pixels)

data/spec/chunky_png/canvas/png_decoding_spec.rb

@@ -6,53 +6,51 @@ describe ChunkyPNG::Canvas::PNGDecoding do
   describe '#decode_png_scanline' do
 
     it "should decode a line without filtering as is" do
-      bytes = [255, 255, 255, 255, 255, 255, 255, 255, 255]
-      decode_png_scanline(ChunkyPNG::FILTER_NONE, bytes, nil).should == bytes
+      stream = [ChunkyPNG::FILTER_NONE, 255, 255, 255, 255, 255, 255, 255, 255, 255].pack('C*')
+      decode_png_str_scanline(stream, 0, nil, 9, 3)
+      stream.unpack('@1C*').should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
     end
 
     it "should decode a line with sub filtering correctly" do
       # all white pixels
-      bytes = [255, 255, 255, 0, 0, 0, 0, 0, 0]
-      decoded_bytes = decode_png_scanline(ChunkyPNG::FILTER_SUB, bytes, nil)
-      decoded_bytes.should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
+      stream = [ChunkyPNG::FILTER_SUB, 255, 255, 255, 0, 0, 0, 0, 0, 0].pack('C*')
+      decode_png_str_scanline(stream, 0, nil, 9, 3)
+      stream.unpack('@1C*').should == [255, 255, 255, 255, 255, 255, 255, 255, 255]
 
       # all black pixels
-      bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0]
-      decoded_bytes = decode_png_scanline(ChunkyPNG::FILTER_SUB, bytes, nil)
-      decoded_bytes.should == [0, 0, 0, 0, 0, 0, 0, 0, 0]
+      stream = [ChunkyPNG::FILTER_SUB, 0, 0, 0, 0, 0, 0, 0, 0, 0].pack('C*')
+      decode_png_str_scanline(stream, 0, nil, 9, 3)
+      stream.unpack('@1C*').should == [0, 0, 0, 0, 0, 0, 0, 0, 0]
 
       # various colors
-      bytes = [255, 0, 45, 0, 255, 0, 112, 200, 178]
-      decoded_bytes = decode_png_scanline(ChunkyPNG::FILTER_SUB, bytes, nil)
-      decoded_bytes.should == [255, 0, 45, 255, 255, 45, 111, 199, 223]
+      stream = [ChunkyPNG::FILTER_SUB, 255, 0, 45, 0, 255, 0, 112, 200, 178].pack('C*')
+      decode_png_str_scanline(stream, 0, nil, 9, 3)
+      stream.unpack('@1C*').should == [255, 0, 45, 255, 255, 45, 111, 199, 223]
     end
 
     it "should decode a line with up filtering correctly" do
-      # previous line is all black
-      previous_bytes = [0, 0, 0, 0, 0, 0, 0, 0, 0]
-      bytes          = [255, 255, 255, 127, 127, 127, 0, 0, 0]
-      decoded_bytes  = decode_png_scanline(ChunkyPNG::FILTER_UP, bytes, previous_bytes)
-      decoded_bytes.should == [255, 255, 255, 127, 127, 127, 0, 0, 0]
-
       # previous line has various pixels
-      previous_bytes = [255, 255, 255, 127, 127, 127, 0, 0, 0]
-      bytes          = [0, 127, 255, 0, 127, 255, 0, 127, 255]
-      decoded_bytes  = decode_png_scanline(ChunkyPNG::FILTER_UP, bytes, previous_bytes)
-      decoded_bytes.should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
+      previous = [ChunkyPNG::FILTER_UP, 255, 255, 255, 127, 127, 127, 0, 0, 0]
+      current  = [ChunkyPNG::FILTER_UP, 0, 127, 255, 0, 127, 255, 0, 127, 255]
+      stream   = (previous + current).pack('C*')
+      decode_png_str_scanline(stream, 10, 0, 9, 3)
+      stream.unpack('@11C9').should == [255, 126, 254, 127, 254, 126, 0, 127, 255]
     end
     
     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, 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]
+      previous = [ChunkyPNG::FILTER_AVERAGE, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
+      current  = [ChunkyPNG::FILTER_AVERAGE,  0,  0, 10, 23, 15, 13, 23, 63, 38,  60, 253,  53]
+      stream   = (previous + current).pack('C*')
+      decode_png_str_scanline(stream, 13, 0, 12, 3)
+      stream.unpack('@14C12').should == [5, 10, 25, 45, 45, 55, 80, 125, 105, 150, 114, 165]
     end
 
     it "should decode a line with paeth 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]
-      decoded  = decode_png_scanline(ChunkyPNG::FILTER_PAETH, current, previous)
-      decoded.should == [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
+      previous = [ChunkyPNG::FILTER_PAETH, 10, 20, 30, 40, 50, 60, 70, 80, 80, 100, 110, 120]
+      current  = [ChunkyPNG::FILTER_PAETH,  0,  0, 10, 20, 10,  0,  0, 40, 10,  20, 190,   0]
+      stream   = (previous + current).pack('C*')
+      decode_png_str_scanline(stream, 13, 0, 12, 3)
+      stream.unpack('@14C12').should == [10, 20, 40, 60, 60, 60, 70, 120, 90, 120, 54, 120]
     end
   end