module ChunkyPNG::Canvas::PNGDecoding
The PNGDecoding
contains methods for decoding PNG datastreams to create a Canvas
object. The datastream can be provided as filename, string or IO stream.
Overview of the decoding process:
-
The optional PLTE and tRNS chunk are decoded for the color palette of the original image.
-
The contents of the IDAT chunks is combined, and uncompressed using Inflate decompression to the image pixelstream.
-
Based on the color mode, width and height of the original image, which is read from the PNG header (IHDR chunk), the amount of bytes per line is determined.
-
For every line of pixels in the encoded image, the original byte values are restored by unapplying the milter method for that line.
-
The read bytes are unfiltered given by the filter function specified by the first byte of the line.
-
The unfiltered pixelstream are is into colored pixels, using the color mode.
-
All lines combined to form the original image.
For interlaced images, the original image was split into 7 subimages. These images get decoded just like the process above (from step 3), and get combined to form the original images.
@see ChunkyPNG::Canvas::PNGEncoding
@see www.w3.org/TR/PNG/ The W3C PNG format specification
Public Instance Methods
Decodes a canvas from a PNG encoded pixelstream, using a given width, height, color mode and interlacing mode. @param [String] stream The pixelstream to read from. @param [Integer] width The width of the image. @param [Integer] width The height of the image. @param [Integer] color_mode The color mode of the encoded pixelstream. @param [Integer] depth The bit depth of the pixel samples. @param [Integer] interlace The interlace method of the encoded pixelstream. @param [ChunkyPNG::Palette] decoding_palette The palette to use to decode colors. @param [Integer] transparent_color The color that should be considered fully transparent. @return [ChunkyPNG::Canvas] The decoded Canvas
instance.
# File lib/chunky_png/canvas/png_decoding.rb 95 def decode_png_pixelstream(stream, width, height, color_mode, depth, interlace, decoding_palette, transparent_color) 96 raise ChunkyPNG::ExpectationFailed, "This palette is not suitable for decoding!" if decoding_palette && !decoding_palette.can_decode? 97 98 image = case interlace 99 when ChunkyPNG::INTERLACING_NONE; decode_png_without_interlacing(stream, width, height, color_mode, depth, decoding_palette) 100 when ChunkyPNG::INTERLACING_ADAM7; decode_png_with_adam7_interlacing(stream, width, height, color_mode, depth, decoding_palette) 101 else raise ChunkyPNG::NotSupported, "Don't know how the handle interlacing method #{interlace}!" 102 end 103 104 image.pixels.map! { |c| c == transparent_color ? ChunkyPNG::Color::TRANSPARENT : c } if transparent_color 105 return image 106 end
Decodes a Canvas
from a PNG encoded string. @param [String] str The string to read from. @return [ChunkyPNG::Canvas] The canvas decoded from the PNG encoded string.
# File lib/chunky_png/canvas/png_decoding.rb 35 def from_blob(str) 36 from_datastream(ChunkyPNG::Datastream.from_blob(str)) 37 end
Decodes the Canvas
from a PNG datastream instance. @param [ChunkyPNG::Datastream] ds The datastream to decode. @return [ChunkyPNG::Canvas] The canvas decoded from the PNG datastream.
# File lib/chunky_png/canvas/png_decoding.rb 60 def from_datastream(ds) 61 width = ds.header_chunk.width 62 height = ds.header_chunk.height 63 color_mode = ds.header_chunk.color 64 interlace = ds.header_chunk.interlace 65 depth = ds.header_chunk.depth 66 67 if width == 0 || height == 0 68 raise ExpectationFailed, "Invalid image size, width: #{width}, height: #{height}" 69 end 70 71 decoding_palette, transparent_color = nil, nil 72 case color_mode 73 when ChunkyPNG::COLOR_INDEXED 74 decoding_palette = ChunkyPNG::Palette.from_chunks(ds.palette_chunk, ds.transparency_chunk) 75 when ChunkyPNG::COLOR_TRUECOLOR 76 transparent_color = ds.transparency_chunk.truecolor_entry(depth) if ds.transparency_chunk 77 when ChunkyPNG::COLOR_GRAYSCALE 78 transparent_color = ds.transparency_chunk.grayscale_entry(depth) if ds.transparency_chunk 79 end 80 81 decode_png_pixelstream(ds.imagedata, width, height, color_mode, depth, interlace, decoding_palette, transparent_color) 82 end
Decodes a Canvas
from a PNG encoded file. @param [String] filename The file to read from. @return [ChunkyPNG::Canvas] The canvas decoded from the PNG file.
# File lib/chunky_png/canvas/png_decoding.rb 44 def from_file(filename) 45 from_datastream(ChunkyPNG::Datastream.from_file(filename)) 46 end
Decodes a Canvas
from a PNG encoded stream. @param [IO, read] io The stream to read from. @return [ChunkyPNG::Canvas] The canvas decoded from the PNG stream.
# File lib/chunky_png/canvas/png_decoding.rb 51 def from_io(io) 52 from_datastream(ChunkyPNG::Datastream.from_io(io)) 53 end
Protected Instance Methods
Extract a bit from a byte on a given index. @param [Integer] byte The byte (0..255) value to extract a bit from. @param [Integer] index The index within the byte. This should be 0..7;
the value will be modded by 8 to enforce this.
@return [Integer] Either 1 or 0.
# File lib/chunky_png/canvas/png_decoding.rb 168 def decode_png_extract_1bit_value(byte, index) 169 bitshift = 7 - (index & 0x07) 170 (byte & (0x01 << bitshift)) >> bitshift 171 end
Extract 2 consecutive bits from a byte. @param [Integer] byte The byte (0..255) value to extract a 2 bit value from. @param [Integer] index The index within the byte. This should be either 0, 1, 2, or 3;
the value will be modded by 4 to enforce this.
@return [Integer] The extracted 2 bit value (0..3)
# File lib/chunky_png/canvas/png_decoding.rb 158 def decode_png_extract_2bit_value(byte, index) 159 bitshift = 6 - ((index & 0x03) << 1) 160 (byte & (0x03 << bitshift)) >> bitshift 161 end
Extract 4 consecutive bits from a byte. @param [Integer] byte The byte (0..255) value to extract a 4 bit value from. @param [Integer] index The index within the byte. This should be either 0 or 2;
the value will be modded by 2 to enforce this.
@return [Integer] The extracted 4bit value (0..15)
# File lib/chunky_png/canvas/png_decoding.rb 149 def decode_png_extract_4bit_value(byte, index) 150 (index & 0x01 == 0) ? ((byte & 0xf0) >> 4) : (byte & 0x0f) 151 end
Decodes a single PNG image pass width a given width, height and color mode, to a Canvas
, starting at the given position in the stream.
A non-interlaced image only consists of one pass, while an Adam7 image consists of 7 passes that must be combined after decoding.
@param stream (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param width (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param height (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param color_mode (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param [Integer] start_pos The position in the pixel stream to start reading. @param [ChunkyPNG::Palette] decoding_palette The palette to use to decode colors. @return (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
)
# File lib/chunky_png/canvas/png_decoding.rb 381 def decode_png_image_pass(stream, width, height, color_mode, depth, start_pos, decoding_palette) 382 383 pixels = [] 384 if width > 0 && height > 0 385 386 stream << ChunkyPNG::EXTRA_BYTE if color_mode == ChunkyPNG::COLOR_TRUECOLOR 387 pixel_decoder = decode_png_pixels_from_scanline_method(color_mode, depth) 388 line_length = ChunkyPNG::Color.scanline_bytesize(color_mode, depth, width) 389 pixel_size = ChunkyPNG::Color.pixel_bytesize(color_mode, depth) 390 391 raise ChunkyPNG::ExpectationFailed, "Invalid stream length!" unless stream.bytesize - start_pos >= ChunkyPNG::Color.pass_bytesize(color_mode, depth, width, height) 392 393 pos, prev_pos = start_pos, nil 394 for _ in 0...height do 395 decode_png_str_scanline(stream, pos, prev_pos, line_length, pixel_size) 396 pixels.concat(send(pixel_decoder, stream, pos, width, decoding_palette)) 397 398 prev_pos = pos 399 pos += line_length + 1 400 end 401 end 402 403 new(width, height, pixels) 404 end
Decodes a scanline of a 16-bit, grayscale image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 344 def decode_png_pixels_from_scanline_grayscale_16bit(stream, pos, width, _decoding_palette) 345 values = stream.unpack("@#{pos + 1}n#{width}") 346 values.map { |value| ChunkyPNG::Color.grayscale(decode_png_resample_16bit_value(value)) } 347 end
Decodes a scanline of a 1-bit, grayscale image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 307 def decode_png_pixels_from_scanline_grayscale_1bit(stream, pos, width, _decoding_palette) 308 (0...width).map do |index| 309 value = decode_png_extract_1bit_value(stream.getbyte(pos + 1 + (index >> 3)), index) 310 value == 1 ? ChunkyPNG::Color::WHITE : ChunkyPNG::Color::BLACK 311 end 312 end
Decodes a scanline of a 2-bit, grayscale image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 317 def decode_png_pixels_from_scanline_grayscale_2bit(stream, pos, width, _decoding_palette) 318 (0...width).map do |index| 319 value = decode_png_extract_2bit_value(stream.getbyte(pos + 1 + (index >> 2)), index) 320 ChunkyPNG::Color.grayscale(decode_png_resample_2bit_value(value)) 321 end 322 end
Decodes a scanline of a 4-bit, grayscale image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 327 def decode_png_pixels_from_scanline_grayscale_4bit(stream, pos, width, _decoding_palette) 328 (0...width).map do |index| 329 value = decode_png_extract_4bit_value(stream.getbyte(pos + 1 + (index >> 1)), index) 330 ChunkyPNG::Color.grayscale(decode_png_resample_4bit_value(value)) 331 end 332 end
Decodes a scanline of an 8-bit, grayscale image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 337 def decode_png_pixels_from_scanline_grayscale_8bit(stream, pos, width, _decoding_palette) 338 (1..width).map { |i| ChunkyPNG::Color.grayscale(stream.getbyte(pos + i)) } 339 end
Decodes a scanline of a 16-bit, grayscale image with transparency into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 296 def decode_png_pixels_from_scanline_grayscale_alpha_16bit(stream, pos, width, _decoding_palette) 297 pixels = [] 298 stream.unpack("@#{pos + 1}n#{width * 2}").each_slice(2) do |g, a| 299 pixels << ChunkyPNG::Color.grayscale_alpha(decode_png_resample_16bit_value(g), decode_png_resample_16bit_value(a)) 300 end 301 return pixels 302 end
Decodes a scanline of an 8-bit, grayscale image with transparency into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 289 def decode_png_pixels_from_scanline_grayscale_alpha_8bit(stream, pos, width, _decoding_palette) 290 (0...width).map { |i| ChunkyPNG::Color.grayscale_alpha(stream.getbyte(pos + (i * 2) + 1), stream.getbyte(pos + (i * 2) + 2)) } 291 end
Decodes a scanline of a 1-bit, indexed image into a row of pixels. @param [String] stream The stream to decode from. @param [Integer] pos The position in the stream on which the scanline starts (including the filter byte). @param [Integer] width The width in pixels of the scanline. @param [ChunkyPNG::Palette] decoding_palette The palette to use to decode colors. @return [Array<Integer>] An array of decoded pixels.
# File lib/chunky_png/canvas/png_decoding.rb 215 def decode_png_pixels_from_scanline_indexed_1bit(stream, pos, width, decoding_palette) 216 (0...width).map do |index| 217 palette_pos = decode_png_extract_1bit_value(stream.getbyte(pos + 1 + (index >> 3)), index) 218 decoding_palette[palette_pos] 219 end 220 end
Decodes a scanline of a 2-bit, indexed image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 225 def decode_png_pixels_from_scanline_indexed_2bit(stream, pos, width, decoding_palette) 226 (0...width).map do |index| 227 palette_pos = decode_png_extract_2bit_value(stream.getbyte(pos + 1 + (index >> 2)), index) 228 decoding_palette[palette_pos] 229 end 230 end
Decodes a scanline of a 4-bit, indexed image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 235 def decode_png_pixels_from_scanline_indexed_4bit(stream, pos, width, decoding_palette) 236 (0...width).map do |index| 237 palette_pos = decode_png_extract_4bit_value(stream.getbyte(pos + 1 + (index >> 1)), index) 238 decoding_palette[palette_pos] 239 end 240 end
Decodes a scanline of a 8-bit, indexed image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 245 def decode_png_pixels_from_scanline_indexed_8bit(stream, pos, width, decoding_palette) 246 (1..width).map { |i| decoding_palette[stream.getbyte(pos + i)] } 247 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.
# File lib/chunky_png/canvas/png_decoding.rb 354 def decode_png_pixels_from_scanline_method(color_mode, depth) 355 decoder_method = case color_mode 356 when ChunkyPNG::COLOR_TRUECOLOR; :"decode_png_pixels_from_scanline_truecolor_#{depth}bit" 357 when ChunkyPNG::COLOR_TRUECOLOR_ALPHA; :"decode_png_pixels_from_scanline_truecolor_alpha_#{depth}bit" 358 when ChunkyPNG::COLOR_INDEXED; :"decode_png_pixels_from_scanline_indexed_#{depth}bit" 359 when ChunkyPNG::COLOR_GRAYSCALE; :"decode_png_pixels_from_scanline_grayscale_#{depth}bit" 360 when ChunkyPNG::COLOR_GRAYSCALE_ALPHA; :"decode_png_pixels_from_scanline_grayscale_alpha_#{depth}bit" 361 else nil 362 end 363 364 raise ChunkyPNG::NotSupported, "No decoder found for color mode #{color_mode} and #{depth}-bit depth!" unless respond_to?(decoder_method, true) 365 decoder_method 366 end
Decodes a scanline of a 16-bit, true color image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 278 def decode_png_pixels_from_scanline_truecolor_16bit(stream, pos, width, _decoding_palette) 279 pixels = [] 280 stream.unpack("@#{pos + 1}n#{width * 3}").each_slice(3) do |r, g, b| 281 pixels << ChunkyPNG::Color.rgb(decode_png_resample_16bit_value(r), decode_png_resample_16bit_value(g), decode_png_resample_16bit_value(b)) 282 end 283 return pixels 284 end
Decodes a scanline of an 8-bit, true color image into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 271 def decode_png_pixels_from_scanline_truecolor_8bit(stream, pos, width, _decoding_palette) 272 stream.unpack("@#{pos + 1}" << ('NX' * width)).map { |c| c | 0x000000ff } 273 end
Decodes a scanline of a 16-bit, true color image with transparency into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 259 def decode_png_pixels_from_scanline_truecolor_alpha_16bit(stream, pos, width, _decoding_palette) 260 pixels = [] 261 stream.unpack("@#{pos + 1}n#{width * 4}").each_slice(4) do |r, g, b, a| 262 pixels << ChunkyPNG::Color.rgba(decode_png_resample_16bit_value(r), decode_png_resample_16bit_value(g), 263 decode_png_resample_16bit_value(b), decode_png_resample_16bit_value(a)) 264 end 265 return pixels 266 end
Decodes a scanline of an 8-bit, true color image with transparency into a row of pixels. @params (see decode_png_pixels_from_scanline_indexed_1bit
) @return (see decode_png_pixels_from_scanline_indexed_1bit
)
# File lib/chunky_png/canvas/png_decoding.rb 252 def decode_png_pixels_from_scanline_truecolor_alpha_8bit(stream, pos, width, _decoding_palette) 253 stream.unpack("@#{pos + 1}N#{width}") 254 end
Resamples a 16 bit value to an 8 bit value. This will discard some color information. @param [Integer] value The 16 bit value to resample. @return [Integer] The 8 bit resampled value
# File lib/chunky_png/canvas/png_decoding.rb 176 def decode_png_resample_16bit_value(value) 177 value >> 8 178 end
Resamples a 1 bit value to an 8 bit value. @param [Integer] value The 1 bit value to resample. @return [Integer] The 8 bit resampled value
# File lib/chunky_png/canvas/png_decoding.rb 204 def decode_png_resample_1bit_value(value) 205 value == 0x01 ? 0xff : 0x00 206 end
Resamples a 2 bit value to an 8 bit value. @param [Integer] value The 2 bit value to resample. @return [Integer] The 8 bit resampled value.
# File lib/chunky_png/canvas/png_decoding.rb 197 def decode_png_resample_2bit_value(value) 198 value << 6 | value << 4 | value << 2 | value 199 end
Resamples a 4 bit value to an 8 bit value. @param [Integer] value The 4 bit value to resample. @return [Integer] The 8 bit resampled value.
# File lib/chunky_png/canvas/png_decoding.rb 190 def decode_png_resample_4bit_value(value) 191 value << 4 | value 192 end
No-op - available for completeness sake only @param [Integer] value The 8 bit value to resample. @return [Integer] The 8 bit resampled value
# File lib/chunky_png/canvas/png_decoding.rb 183 def decode_png_resample_8bit_value(value) 184 value 185 end
Decodes a scanline if it was encoded using filtering.
It will extract the filtering method from the first byte of the scanline, and uses the method to change the subsequent bytes to unfiltered values. This will modify the pixelstream.
The bytes of the scanline can then be used to construct pixels, based on the color mode..
@param [String] stream The pixelstream to undo the filtering in. @param [Integer] pos The starting position of the scanline to decode. @param [Integer, nil] prev_pos The starting position of the previously decoded scanline, or nil
if this is the first scanline of the image.
@param [Integer] line_length The number of bytes in the scanline, discounting the filter method byte. @param [Integer] pixel_size The number of bytes used per pixel, based on the color mode. @return [void]
# File lib/chunky_png/canvas/png_decoding.rb 420 def decode_png_str_scanline(stream, pos, prev_pos, line_length, pixel_size) 421 case stream.getbyte(pos) 422 when ChunkyPNG::FILTER_NONE; # noop 423 when ChunkyPNG::FILTER_SUB; decode_png_str_scanline_sub( stream, pos, prev_pos, line_length, pixel_size) 424 when ChunkyPNG::FILTER_UP; decode_png_str_scanline_up( stream, pos, prev_pos, line_length, pixel_size) 425 when ChunkyPNG::FILTER_AVERAGE; decode_png_str_scanline_average( stream, pos, prev_pos, line_length, pixel_size) 426 when ChunkyPNG::FILTER_PAETH; decode_png_str_scanline_paeth( stream, pos, prev_pos, line_length, pixel_size) 427 else raise ChunkyPNG::NotSupported, "Unknown filter type: #{stream.getbyte(pos)}!" 428 end 429 end
Decodes a scanline in a pixelstream that was encoded using AVERAGE filtering. This will change the pixelstream to have unfiltered values. @params (see decode_png_str_scanline
) @return [void]
# File lib/chunky_png/canvas/png_decoding.rb 463 def decode_png_str_scanline_average(stream, pos, prev_pos, line_length, pixel_size) 464 for i in 1..line_length do 465 a = (i > pixel_size) ? stream.getbyte(pos + i - pixel_size) : 0 466 b = prev_pos ? stream.getbyte(prev_pos + i) : 0 467 stream.setbyte(pos + i, (stream.getbyte(pos + i) + ((a + b) >> 1)) & 0xff) 468 end 469 end
Decodes a scanline in a pixelstream that was encoded using PAETH filtering. This will change the pixelstream to have unfiltered values. @params (see decode_png_str_scanline
) @return [void]
# File lib/chunky_png/canvas/png_decoding.rb 475 def decode_png_str_scanline_paeth(stream, pos, prev_pos, line_length, pixel_size) 476 for i in 1..line_length do 477 cur_pos = pos + i 478 a = (i > pixel_size) ? stream.getbyte(cur_pos - pixel_size) : 0 479 b = prev_pos ? stream.getbyte(prev_pos + i) : 0 480 c = (prev_pos && i > pixel_size) ? stream.getbyte(prev_pos + i - pixel_size) : 0 481 p = a + b - c 482 pa = (p - a).abs 483 pb = (p - b).abs 484 pc = (p - c).abs 485 pr = (pa <= pb) ? (pa <= pc ? a : c) : (pb <= pc ? b : c) 486 stream.setbyte(cur_pos, (stream.getbyte(cur_pos) + pr) & 0xff) 487 end 488 end
Decodes a scanline in a pixelstream that was encoded using SUB filtering. This will change the pixelstream to have unfiltered values. @params (see decode_png_str_scanline
) @return [void]
# File lib/chunky_png/canvas/png_decoding.rb 442 def decode_png_str_scanline_sub(stream, pos, prev_pos, line_length, pixel_size) 443 for i in 1..line_length do 444 stream.setbyte(pos + i, (stream.getbyte(pos + i) + (i > pixel_size ? stream.getbyte(pos + i - pixel_size) : 0)) & 0xff) 445 end 446 end
Decodes a scanline that wasn't encoded using filtering. This is a no-op. @params (see decode_png_str_scanline
) @return [void]
# File lib/chunky_png/canvas/png_decoding.rb 434 def decode_png_str_scanline_sub_none(stream, pos, prev_pos, line_length, pixel_size) 435 # noop - this method shouldn't get called. 436 end
Decodes a scanline in a pixelstream that was encoded using UP filtering. This will change the pixelstream to have unfiltered values. @params (see decode_png_str_scanline
) @return [void]
# File lib/chunky_png/canvas/png_decoding.rb 452 def decode_png_str_scanline_up(stream, pos, prev_pos, line_length, pixel_size) 453 for i in 1..line_length do 454 up = prev_pos ? stream.getbyte(prev_pos + i) : 0 455 stream.setbyte(pos + i, (stream.getbyte(pos + i) + up) & 0xff) 456 end 457 end
Decodes a canvas from a Adam 7 interlaced PNG encoded pixelstream, using a given width, height and color mode. @param stream (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param width (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param height (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param color_mode (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param depth (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param [ChunkyPNG::Palette] decoding_palette The palette to use to decode colors. @return (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
)
# File lib/chunky_png/canvas/png_decoding.rb 132 def decode_png_with_adam7_interlacing(stream, width, height, color_mode, depth, decoding_palette) 133 canvas = new(width, height) 134 start_pos = 0 135 for pass in 0...7 136 sm_width, sm_height = adam7_pass_size(pass, width, height) 137 sm = decode_png_image_pass(stream, sm_width, sm_height, color_mode, depth, start_pos, decoding_palette) 138 adam7_merge_pass(pass, canvas, sm) 139 start_pos += ChunkyPNG::Color.pass_bytesize(color_mode, depth, sm_width, sm_height) 140 end 141 canvas 142 end
Decodes a canvas from a non-interlaced PNG encoded pixelstream, using a given width, height and color mode. @param stream (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param width (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param height (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param color_mode (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param depth (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
) @param [ChunkyPNG::Palette] decoding_palette The palette to use to decode colors. @return (see ChunkyPNG::Canvas::PNGDecoding#decode_png_pixelstream
)
# File lib/chunky_png/canvas/png_decoding.rb 119 def decode_png_without_interlacing(stream, width, height, color_mode, depth, decoding_palette) 120 decode_png_image_pass(stream, width, height, color_mode, depth, 0, decoding_palette) 121 end