chunky_png 1.3.8 → 1.4.0

data/lib/chunky_png/canvas/stream_exporting.rb

@@ -1,9 +1,9 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   class Canvas
-
     # Methods to save load a canvas from to stream, encoded in RGB, RGBA, BGR or ABGR format.
     module StreamExporting
-
       # Creates an RGB-formatted pixelstream with the pixel data from this canvas.
       #
       # Note that this format is fast but bloated, because no compression is used
@@ -12,7 +12,7 @@ module ChunkyPNG
       #
       # @return [String] The RGBA-formatted pixel data.
       def to_rgba_stream
-        pixels.pack('N*')
+        pixels.pack("N*")
       end
 
       # Creates an RGB-formatted pixelstream with the pixel data from this canvas.
@@ -23,14 +23,14 @@ module ChunkyPNG
       #
       # @return [String] The RGB-formatted pixel data.
       def to_rgb_stream
-        pixels.pack('NX' * pixels.length)
+        pixels.pack("NX" * pixels.length)
       end
-      
+
       # Creates a stream of the alpha channel of this canvas.
       #
       # @return [String] The 0-255 alpha values of all pixels packed as string
       def to_alpha_channel_stream
-        pixels.pack('C*')
+        pixels.pack("C*")
       end
 
       # Creates a grayscale stream of this canvas.
@@ -40,7 +40,7 @@ module ChunkyPNG
       #
       # @return [String] The 0-255 grayscale values of all pixels packed as string.
       def to_grayscale_stream
-        pixels.pack('nX' * pixels.length)
+        pixels.pack("nX" * pixels.length)
       end
 
       # Creates an ABGR-formatted pixelstream with the pixel data from this canvas.
@@ -51,7 +51,7 @@ module ChunkyPNG
       #
       # @return [String] The RGBA-formatted pixel data.
       def to_abgr_stream
-        pixels.pack('V*')
+        pixels.pack("V*")
       end
     end
   end

data/lib/chunky_png/canvas/stream_importing.rb

@@ -1,9 +1,9 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   class Canvas
-
     # Methods to quickly load a canvas from a stream, encoded in RGB, RGBA, BGR or ABGR format.
     module StreamImporting
-
       # Creates a canvas by reading pixels from an RGB formatted stream with a
       # provided with and height.
       #
@@ -18,9 +18,9 @@ module ChunkyPNG
       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 << ChunkyPNG::EXTRA_BYTE # Add a fourth byte to the last RGB triple.
-        unpacker = 'NX' * (width * height)
+        unpacker = "NX" * (width * height)
         pixels = string.unpack(unpacker).map { |color| color | 0x000000ff }
-        self.new(width, height, pixels)
+        new(width, height, pixels)
       end
 
       # Creates a canvas by reading pixels from an RGBA formatted stream with a
@@ -36,7 +36,7 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_rgba_stream(width, height, stream)
         string = stream.respond_to?(:read) ? stream.read(4 * width * height) : stream.to_s[0, 4 * width * height]
-        self.new(width, height, string.unpack("N*"))
+        new(width, height, string.unpack("N*"))
       end
 
       # Creates a canvas by reading pixels from an BGR formatted stream with a
@@ -53,8 +53,8 @@ module ChunkyPNG
       def from_bgr_stream(width, height, stream)
         string = ChunkyPNG::EXTRA_BYTE.dup # 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)
+        pixels = string.unpack("@1#{"XV" * (width * height)}").map { |color| color | 0x000000ff }
+        new(width, height, pixels)
       end
 
       # Creates a canvas by reading pixels from an ARGB formatted stream with a
@@ -70,7 +70,7 @@ module ChunkyPNG
       # @return [ChunkyPNG::Canvas] The newly constructed canvas instance.
       def from_abgr_stream(width, height, stream)
         string = stream.respond_to?(:read) ? stream.read(4 * width * height) : stream.to_s[0, 4 * width * height]
-        self.new(width, height, string.unpack("V*"))
+        new(width, height, string.unpack("V*"))
       end
     end
   end

data/lib/chunky_png/canvas.rb

@@ -1,14 +1,16 @@
-require 'chunky_png/canvas/png_encoding'
-require 'chunky_png/canvas/png_decoding'
-require 'chunky_png/canvas/adam7_interlacing'
-require 'chunky_png/canvas/stream_exporting'
-require 'chunky_png/canvas/stream_importing'
-require 'chunky_png/canvas/data_url_exporting'
-require 'chunky_png/canvas/data_url_importing'
-require 'chunky_png/canvas/operations'
-require 'chunky_png/canvas/drawing'
-require 'chunky_png/canvas/resampling'
-require 'chunky_png/canvas/masking'
+# frozen-string-literal: true
+
+require "chunky_png/canvas/png_encoding"
+require "chunky_png/canvas/png_decoding"
+require "chunky_png/canvas/adam7_interlacing"
+require "chunky_png/canvas/stream_exporting"
+require "chunky_png/canvas/stream_importing"
+require "chunky_png/canvas/data_url_exporting"
+require "chunky_png/canvas/data_url_importing"
+require "chunky_png/canvas/operations"
+require "chunky_png/canvas/drawing"
+require "chunky_png/canvas/resampling"
+require "chunky_png/canvas/masking"
 
 module ChunkyPNG
   # The ChunkyPNG::Canvas class represents a raster image as a matrix of
@@ -56,7 +58,6 @@ module ChunkyPNG
     #   This array always should have +width * height+ elements.
     attr_reader :pixels
 
-
     #################################################################
     # CONSTRUCTORS
     #################################################################
@@ -68,7 +69,7 @@ module ChunkyPNG
     #   @param [Integer] height The height in pixels of this canvas
     #   @param [Integer, ...] background_color The initial background color of
     #     this canvas. This can be a color value or any value that
-    #     {ChunkyPNG::Color.parse} can handle.
+    #     {ChunkyPNG::Color#parse} can handle.
     #
     # @overload initialize(width, height, initial)
     #   @param [Integer] width The width in pixels of this canvas
@@ -78,9 +79,10 @@ module ChunkyPNG
     def initialize(width, height, initial = ChunkyPNG::Color::TRANSPARENT)
       @width, @height = width, height
 
-      if initial.kind_of?(Array)
-        unless initial.length == width * height
-          raise ArgumentError, "The initial array should have #{width}x#{height} = #{width*height} elements!"
+      if initial.is_a?(Array)
+        pixel_count = width * height
+        unless initial.length == pixel_count
+          raise ArgumentError, "The initial array should have #{width}x#{height} = #{pixel_count} elements!"
         end
         @pixels = initial
       else
@@ -104,7 +106,6 @@ module ChunkyPNG
       new(canvas.width, canvas.height, canvas.pixels.dup)
     end
 
-
     #################################################################
     # PROPERTIES
     #################################################################
@@ -143,7 +144,7 @@ module ChunkyPNG
     #
     # @param [Integer] x The x-coordinate of the pixel (column)
     # @param [Integer] y The y-coordinate of the pixel (row)
-    # @param [Integer] pixel The new color for the provided coordinates.
+    # @param [Integer] color The new color for the provided coordinates.
     # @return [Integer] The new color value for this pixel, i.e.
     #   <tt>color</tt>.
     def set_pixel(x, y, color)
@@ -155,7 +156,7 @@ module ChunkyPNG
     #
     # @param [Integer] x The x-coordinate of the pixel (column)
     # @param [Integer] y The y-coordinate of the pixel (row)
-    # @param [Integer] pixel The new color value for the provided coordinates.
+    # @param [Integer] color The new color value for the provided coordinates.
     # @return [Integer] The new color value for this pixel, i.e.
     #   <tt>color</tt>, or <tt>nil</tt> if the coordinates are out of bounds.
     def set_pixel_if_within_bounds(x, y, color)
@@ -233,7 +234,7 @@ module ChunkyPNG
       dimension.include?(ChunkyPNG::Point(*point_like))
     end
 
-    alias_method :include?,    :include_point?
+    alias include? include_point?
 
     # Checks whether the given x- and y-coordinate are in the range of the
     # canvas
@@ -274,11 +275,13 @@ module ChunkyPNG
     # @return [true, false] True if the size and pixel values of the other
     #   canvas are exactly the same as this canvas's size and pixel values.
     def eql?(other)
-      other.kind_of?(self.class) && other.pixels == self.pixels &&
-            other.width == self.width && other.height == self.height
+      other.is_a?(self.class) &&
+        other.pixels == pixels &&
+        other.width == width &&
+        other.height == height
     end
 
-    alias :== :eql?
+    alias == eql?
 
     #################################################################
     # EXPORTING
@@ -294,9 +297,9 @@ module ChunkyPNG
     # @return [String] A nicely formatted string representation of this canvas.
     # @private
     def inspect
-      inspected = "<#{self.class.name} #{width}x#{height} ["
+      inspected = +"<#{self.class.name} #{width}x#{height} ["
       for y in 0...height
-        inspected << "\n\t[" << row(y).map { |p| ChunkyPNG::Color.to_hex(p) }.join(' ') << ']'
+        inspected << "\n\t[" << row(y).map { |p| ChunkyPNG::Color.to_hex(p) }.join(" ") << "]"
       end
       inspected << "\n]>"
     end
@@ -358,13 +361,13 @@ module ChunkyPNG
 
     # Throws an exception if the matrix width and height does not match this canvas' dimensions.
     def assert_size!(matrix_width, matrix_height)
-      if width  != matrix_width
+      if width != matrix_width
         raise ChunkyPNG::ExpectationFailed,
-          'The width of the matrix does not match the canvas width!'
+          "The width of the matrix does not match the canvas width!"
       end
       if height != matrix_height
         raise ChunkyPNG::ExpectationFailed,
-          'The height of the matrix does not match the canvas height!'
+          "The height of the matrix does not match the canvas height!"
       end
       true
     end

data/lib/chunky_png/chunk.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module ChunkyPNG
   # A PNG datastream consists of multiple chunks. This module, and the classes
   # contained within, help with handling these chunks. It supports both reading
@@ -16,10 +18,10 @@ module ChunkyPNG
     # @param io [IO, #read] The IO stream to read from.
     # @return [ChunkyPNG::Chung::Base] The loaded chunk instance.
     def self.read(io)
-      length, type = read_bytes(io, 8).unpack('Na4')
+      length, type = read_bytes(io, 8).unpack("Na4")
 
       content = read_bytes(io, length)
-      crc     = read_bytes(io, 4).unpack('N').first
+      crc     = read_bytes(io, 4).unpack("N").first
       verify_crc!(type, content, crc)
 
       CHUNK_TYPES.fetch(type, Generic).read(type, content)
@@ -74,8 +76,8 @@ module ChunkyPNG
       # @param io [IO] The IO stream to write to.
       # @param content [String] The content for this chunk.
       def write_with_crc(io, content)
-        io << [content.length].pack('N') << type << content
-        io << [Zlib.crc32(content, Zlib.crc32(type))].pack('N')
+        io << [content.length].pack("N") << type << content
+        io << [Zlib.crc32(content, Zlib.crc32(type))].pack("N")
       end
 
       # Writes the chunk to the IO stream.
@@ -84,7 +86,7 @@ module ChunkyPNG
       # and will calculate and append the checksum automatically.
       # @param io [IO] The IO stream to write to.
       def write(io)
-        write_with_crc(io, content || '')
+        write_with_crc(io, content || "")
       end
     end
 
@@ -95,8 +97,8 @@ module ChunkyPNG
       # written by the +write+ method.
       attr_accessor :content
 
-      def initialize(type, content = '')
-        super(type, :content => content)
+      def initialize(type, content = "")
+        super(type, content: content)
       end
 
       # Creates an instance, given the chunk's type and content.
@@ -117,12 +119,13 @@ module ChunkyPNG
     # PNG spec, except for color depth: Only 8-bit depth images are supported.
     # Note that it is still possible to access the chunk for such an image, but
     # ChunkyPNG will raise an exception if you try to access the pixel data.
+    #
+    # @see https://www.w3.org/TR/PNG/#11IHDR
     class Header < Base
-      attr_accessor :width, :height, :depth, :color, :compression, :filtering,
-                    :interlace
+      attr_accessor :width, :height, :depth, :color, :compression, :filtering, :interlace
 
       def initialize(attrs = {})
-        super('IHDR', attrs)
+        super("IHDR", attrs)
         @depth       ||= 8
         @color       ||= ChunkyPNG::COLOR_TRUECOLOR
         @compression ||= ChunkyPNG::COMPRESSION_DEFAULT
@@ -137,31 +140,41 @@ module ChunkyPNG
       # @return [ChunkyPNG::Chunk::End] The new Header chunk instance with the
       #   variables set to the values according to the content.
       def self.read(type, content)
-        fields = content.unpack('NNC5')
-        new(:width => fields[0],
-            :height => fields[1],
-            :depth => fields[2],
-            :color => fields[3],
-            :compression => fields[4],
-            :filtering => fields[5],
-            :interlace => fields[6])
+        fields = content.unpack("NNC5")
+        new(
+          width: fields[0],
+          height: fields[1],
+          depth: fields[2],
+          color: fields[3],
+          compression: fields[4],
+          filtering: fields[5],
+          interlace: fields[6]
+        )
       end
 
       # Returns the content for this chunk when it gets written to a file, by
       # packing the image information variables into the correct format.
       # @return [String] The 13-byte content for the header chunk.
       def content
-        [width, height, depth, color, compression, filtering, interlace].
-          pack('NNC5')
+        [
+          width,
+          height,
+          depth,
+          color,
+          compression,
+          filtering,
+          interlace,
+        ].pack("NNC5")
       end
     end
 
     # The End (IEND) chunk indicates the last chunk of a PNG stream. It does
     # not contain any data.
+    #
+    # @see https://www.w3.org/TR/PNG/#11IEND
     class End < Base
-
       def initialize
-        super('IEND')
+        super("IEND")
       end
 
       # Reads the END chunk. It will check if the content is empty.
@@ -170,22 +183,23 @@ module ChunkyPNG
       # @param content [String] The content read from the chunk. Should be
       #   empty.
       # @return [ChunkyPNG::Chunk::End] The new End chunk instance.
-      # @raise [RuntimeError] Raises an exception if the content was not empty.
+      # @raise [ChunkyPNG::ExpectationFailed] Raises an exception if the content was not empty.
       def self.read(type, content)
-        raise ExpectationFailed, 'The IEND chunk should be empty!' if content.bytesize > 0
-        self.new
+        raise ExpectationFailed, "The IEND chunk should be empty!" if content.bytesize > 0
+        new
       end
 
       # Returns an empty string, because this chunk should always be empty.
       # @return [""] An empty string.
       def content
-        ChunkyPNG::Datastream.empty_bytearray
+        "".b
       end
     end
 
     # The Palette (PLTE) chunk contains the image's palette, i.e. the
     # 8-bit RGB colors this image is using.
     #
+    # @see https://www.w3.org/TR/PNG/#11PLTE
     # @see ChunkyPNG::Chunk::Transparency
     # @see ChunkyPNG::Palette
     class Palette < Generic
@@ -203,6 +217,7 @@ module ChunkyPNG
     # Images having a color mode that already includes an alpha channel, this
     # chunk should not be included.
     #
+    # @see https://www.w3.org/TR/PNG/#11tRNS
     # @see ChunkyPNG::Chunk::Palette
     # @see ChunkyPNG::Palette
     class Transparency < Generic
@@ -214,7 +229,7 @@ module ChunkyPNG
       # @return [Array<Integer>] Returns an array of alpha channel values
       #   [0-255].
       def palette_alpha_channel
-        content.unpack('C*')
+        content.unpack("C*")
       end
 
       # Returns the truecolor entry to be replaced by transparent pixels,
@@ -224,9 +239,8 @@ module ChunkyPNG
       #
       # @return [Integer] The color to replace with fully transparent pixels.
       def truecolor_entry(bit_depth)
-        values = content.unpack('nnn').map do |c|
-          ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", c)
-        end
+        decode_method_name = :"decode_png_resample_#{bit_depth}bit_value"
+        values = content.unpack("nnn").map { |c| ChunkyPNG::Canvas.send(decode_method_name, c) }
         ChunkyPNG::Color.rgb(*values)
       end
 
@@ -238,12 +252,23 @@ module ChunkyPNG
       # @return [Integer] The (grayscale) color to replace with fully
       #   transparent pixels.
       def grayscale_entry(bit_depth)
-        value = ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", content.unpack('n')[0])
+        value = ChunkyPNG::Canvas.send(:"decode_png_resample_#{bit_depth}bit_value", content.unpack("n")[0])
         ChunkyPNG::Color.grayscale(value)
       end
     end
 
+    # An image data (IDAT) chunk holds (part of) the compressed image pixel data.
+    #
+    # The data of an image can be split over multiple chunks, which will have to be combined
+    # and inflated in order to decode an image. See {{.combine_chunks}} to combine chunks
+    # to decode, and {{.split_in_chunks}} for encoding a pixeldata stream into IDAT chunks.
+    #
+    # @see https://www.w3.org/TR/PNG/#11IDAT
     class ImageData < Generic
+      # Combines the list of IDAT chunks and inflates their contents to produce the
+      # pixeldata stream for the image.
+      #
+      # @return [String] The combined, inflated pixeldata as binary string
       def self.combine_chunks(data_chunks)
         zstream = Zlib::Inflate.new
         data_chunks.each { |c| zstream << c.content }
@@ -252,31 +277,38 @@ module ChunkyPNG
         inflated
       end
 
+      # Splits and compresses a pixeldata stream into a list of IDAT chunks.
+      #
+      # @param data [String] The binary string of pixeldata
+      # @param level [Integer] The compression level to use.
+      # @param chunk_size [Integer] The maximum size of a chunk.
+      # @return Array<ChunkyPNG::Chunk::ImageData> The list of IDAT chunks.
       def self.split_in_chunks(data, level = Zlib::DEFAULT_COMPRESSION, chunk_size = 2147483647)
         streamdata = Zlib::Deflate.deflate(data, level)
         # TODO: Split long streamdata over multiple chunks
-        [ ChunkyPNG::Chunk::ImageData.new('IDAT', streamdata) ]
+        [ChunkyPNG::Chunk::ImageData.new("IDAT", streamdata)]
       end
     end
 
     # The Text (tEXt) chunk contains keyword/value metadata about the PNG
-    # stream.  In this chunk, the value is stored uncompressed.
+    # stream. In this chunk, the value is stored uncompressed.
     #
     # The tEXt chunk only supports Latin-1 encoded textual data. If you need
     # UTF-8 support, check out the InternationalText chunk type.
     #
+    # @see https://www.w3.org/TR/PNG/#11tEXt
     # @see ChunkyPNG::Chunk::CompressedText
     # @see ChunkyPNG::Chunk::InternationalText
     class Text < Base
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
-        super('tEXt')
+        super("tEXt")
         @keyword, @value = keyword, value
       end
 
       def self.read(type, content)
-        keyword, value = content.unpack('Z*a*')
+        keyword, value = content.unpack("Z*a*")
         new(keyword, value)
       end
 
@@ -285,7 +317,7 @@ module ChunkyPNG
       #
       # @return The content that should be written to the datastream.
       def content
-        [keyword, value].pack('Z*a*')
+        [keyword, value].pack("Z*a*")
       end
     end
 
@@ -293,18 +325,19 @@ module ChunkyPNG
     # PNG stream. In this chunk, the value is compressed using Deflate
     # compression.
     #
+    # @see https://www.w3.org/TR/PNG/#11zTXt
     # @see ChunkyPNG::Chunk::CompressedText
     # @see ChunkyPNG::Chunk::InternationalText
     class CompressedText < Base
       attr_accessor :keyword, :value
 
       def initialize(keyword, value)
-        super('zTXt')
+        super("zTXt")
         @keyword, @value = keyword, value
       end
 
       def self.read(type, content)
-        keyword, compression, value = content.unpack('Z*Ca*')
+        keyword, compression, value = content.unpack("Z*Ca*")
         raise ChunkyPNG::NotSupported, "Compression method #{compression.inspect} not supported!" unless compression == ChunkyPNG::COMPRESSION_DEFAULT
         new(keyword, Zlib::Inflate.inflate(value))
       end
@@ -314,67 +347,107 @@ module ChunkyPNG
       #
       # @return The content that should be written to the datastream.
       def content
-        [keyword, ChunkyPNG::COMPRESSION_DEFAULT, Zlib::Deflate.deflate(value)].
-          pack('Z*Ca*')
+        [
+          keyword,
+          ChunkyPNG::COMPRESSION_DEFAULT,
+          Zlib::Deflate.deflate(value),
+        ].pack("Z*Ca*")
       end
     end
 
     # The Physical (pHYs) chunk specifies the intended pixel size or aspect
     # ratio for display of the image.
     #
-    # http://www.libpng.org/pub/png/spec/1.2/PNG-Chunks.html#C.pHYs
-    #
-    class Physical < Generic
+    # @see https://www.w3.org/TR/PNG/#11pHYs
+    class Physical < Base
       attr_accessor :ppux, :ppuy, :unit
 
       def initialize(ppux, ppuy, unit = :unknown)
-        raise ArgumentError, 'unit must be either :meters or :unknown' unless [:meters, :unknown].member?(unit)
-        super('pHYs')
+        raise ArgumentError, "unit must be either :meters or :unknown" unless [:meters, :unknown].member?(unit)
+        super("pHYs")
         @ppux, @ppuy, @unit = ppux, ppuy, unit
       end
 
       def dpix
-        raise ChunkyPNG::UnitsUnknown, 'the PNG specifies its physical aspect ratio, but does not specify the units of its pixels\' physical dimensions' unless unit == :meters
+        raise ChunkyPNG::UnitsUnknown, "the PNG specifies its physical aspect ratio, but does not specify the units of its pixels' physical dimensions" unless unit == :meters
         ppux * INCHES_PER_METER
       end
 
       def dpiy
-        raise ChunkyPNG::UnitsUnknown, 'the PNG specifies its physical aspect ratio, but does not specify the units of its pixels\' physical dimensions' unless unit == :meters
+        raise ChunkyPNG::UnitsUnknown, "the PNG specifies its physical aspect ratio, but does not specify the units of its pixels' physical dimensions" unless unit == :meters
         ppuy * INCHES_PER_METER
       end
 
       def self.read(type, content)
-        ppux, ppuy, unit = content.unpack('NNC')
+        ppux, ppuy, unit = content.unpack("NNC")
         unit = unit == 1 ? :meters : :unknown
         new(ppux, ppuy, unit)
       end
 
-      # Creates the content to write to the stream, by concatenating the
-      # keyword with the deflated value, joined by a null character.
-      #
-      # @return The content that should be written to the datastream.
+      # Assembles the content to write to the stream for this chunk.
+      # @return [String] The binary content that should be written to the datastream.
       def content
-        [ppux, ppuy, unit == :meters ? 1 : 0].pack('NNC')
+        [ppux, ppuy, unit == :meters ? 1 : 0].pack("NNC")
       end
 
       INCHES_PER_METER = 0.0254
     end
 
-    # The Text (iTXt) chunk contains keyword/value metadata about the PNG
-    # stream.
+    # The InternationalText (iTXt) chunk contains keyword/value metadata about the PNG
+    # stream, translated to a given locale.
     #
     # The metadata in this chunk can be encoded using UTF-8 characters.
     # Moreover, it is possible to define the language of the metadata, and give
     # a translation of the keyword name. Finally, it supports bot compressed
     # and uncompressed values.
     #
-    # @todo This chunk is currently not implemented, but merely read and
-    #   written back intact.
-    #
+    # @see https://www.w3.org/TR/PNG/#11iTXt
     # @see ChunkyPNG::Chunk::Text
     # @see ChunkyPNG::Chunk::CompressedText
-    class InternationalText < Generic
-      # TODO
+    class InternationalText < Base
+      attr_accessor :keyword, :text, :language_tag, :translated_keyword, :compressed, :compression
+
+      def initialize(keyword, text, language_tag = "", translated_keyword = "", compressed = ChunkyPNG::UNCOMPRESSED_CONTENT, compression = ChunkyPNG::COMPRESSION_DEFAULT)
+        super("iTXt")
+        @keyword = keyword
+        @text = text
+        @language_tag = language_tag
+        @translated_keyword = translated_keyword
+        @compressed = compressed
+        @compression = compression
+      end
+
+      # Reads the iTXt chunk.
+      # @param type [String] The four character chunk type indicator (= "iTXt").
+      # @param content [String] The content read from the chunk.
+      # @return [ChunkyPNG::Chunk::InternationalText] The new End chunk instance.
+      # @raise [ChunkyPNG::InvalidUTF8] If the chunk contains data that is not UTF8-encoded text.
+      # @raise [ChunkyPNG::NotSupported] If the chunk refers to an unsupported compression method.
+      #  Currently uncompressed data and deflate are supported.
+      def self.read(type, content)
+        keyword, compressed, compression, language_tag, translated_keyword, text = content.unpack("Z*CCZ*Z*a*")
+        raise ChunkyPNG::NotSupported, "Compression flag #{compressed.inspect} not supported!" unless compressed == ChunkyPNG::UNCOMPRESSED_CONTENT || compressed == ChunkyPNG::COMPRESSED_CONTENT
+        raise ChunkyPNG::NotSupported, "Compression method #{compression.inspect} not supported!" unless compression == ChunkyPNG::COMPRESSION_DEFAULT
+
+        text = Zlib::Inflate.inflate(text) if compressed == ChunkyPNG::COMPRESSED_CONTENT
+
+        text.force_encoding("utf-8")
+        raise ChunkyPNG::InvalidUTF8, "Invalid unicode encountered in iTXt chunk" unless text.valid_encoding?
+
+        translated_keyword.force_encoding("utf-8")
+        raise ChunkyPNG::InvalidUTF8, "Invalid unicode encountered in iTXt chunk" unless translated_keyword.valid_encoding?
+
+        new(keyword, text, language_tag, translated_keyword, compressed, compression)
+      end
+
+      # Assembles the content to write to the stream for this chunk.
+      # @return [String] The binary content that should be written to the datastream.
+      def content
+        text_field = text.encode("utf-8")
+        text_field = compressed == ChunkyPNG::COMPRESSED_CONTENT ? Zlib::Deflate.deflate(text_field) : text_field
+
+        [keyword, compressed, compression, language_tag, translated_keyword.encode("utf-8"), text_field].pack("Z*CCZ*Z*a*")
+      end
     end
 
     # Maps chunk types to classes, based on the four byte chunk type indicator
@@ -385,15 +458,15 @@ module ChunkyPNG
     #
     # @see ChunkyPNG::Chunk.read
     CHUNK_TYPES = {
-      'IHDR' => Header,
-      'IEND' => End,
-      'IDAT' => ImageData,
-      'PLTE' => Palette,
-      'tRNS' => Transparency,
-      'tEXt' => Text,
-      'zTXt' => CompressedText,
-      'iTXt' => InternationalText,
-      'pHYs' => Physical,
+      "IHDR" => Header,
+      "IEND" => End,
+      "IDAT" => ImageData,
+      "PLTE" => Palette,
+      "tRNS" => Transparency,
+      "tEXt" => Text,
+      "zTXt" => CompressedText,
+      "iTXt" => InternationalText,
+      "pHYs" => Physical,
     }
   end
 end