pure_jpeg 0.1.0

data/lib/pure_jpeg/encoder.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module PureJPEG
+  # Baseline JPEG encoder.
+  #
+  # Encodes a pixel source into JPEG using DCT, quantization, and Huffman
+  # coding. Supports grayscale (1 component) and YCbCr color (3 components,
+  # 4:2:0 chroma subsampling).
+  #
+  # Use {PureJPEG.encode} for a convenient entry point.
+  class Encoder
+    # @return [#width, #height, #[]] the pixel source being encoded
+    attr_reader :source
+    # @return [Integer] the quality level (1-100)
+    attr_reader :quality
+    # @return [Boolean] whether grayscale mode is enabled
+    attr_reader :grayscale
+
+    # Create a new encoder for the given pixel source.
+    #
+    # @param source [#width, #height, #[]] any object responding to +width+,
+    #   +height+, and +[x, y]+ (returning an object with +.r+, +.g+, +.b+)
+    # @param quality [Integer] overall compression quality, 1-100 (default 85)
+    # @param grayscale [Boolean] encode as single-channel grayscale (default false)
+    # @param chroma_quality [Integer, nil] independent quality for Cb/Cr channels,
+    #   1-100 (defaults to +quality+)
+    # @param luminance_table [Array<Integer>, nil] custom 64-element quantization
+    #   table in raster order for the Y channel; overrides +quality+ for luma
+    # @param chrominance_table [Array<Integer>, nil] custom 64-element quantization
+    #   table in raster order for Cb/Cr channels; overrides +chroma_quality+
+    # @param quantization_modifier [Proc, nil] a proc receiving +(table, channel)+
+    #   where +channel+ is +:luminance+ or +:chrominance+, returning a modified
+    #   table; applied after quality scaling but before encoding
+    # @param scramble_quantization [Boolean] write quantization tables in raster
+    #   order instead of zigzag (non-spec-compliant; recreates the "early digicam"
+    #   artifact look when decoded by standard viewers)
+    def initialize(source, quality: 85, grayscale: false, chroma_quality: nil,
+                   luminance_table: nil, chrominance_table: nil,
+                   quantization_modifier: nil, scramble_quantization: false)
+      @source = source
+      @quality = quality
+      @grayscale = grayscale
+      @chroma_quality = chroma_quality || quality
+      @luminance_table = luminance_table
+      @chrominance_table = chrominance_table
+      @quantization_modifier = quantization_modifier
+      @scramble_quantization = scramble_quantization
+    end
+
+    # Write the encoded JPEG to a file.
+    #
+    # @param path [String] output file path
+    # @return [void]
+    def write(path)
+      File.open(path, "wb") { |f| encode(f) }
+    end
+
+    # Return the encoded JPEG as a binary string.
+    #
+    # @return [String] raw JPEG bytes
+    def to_bytes
+      io = StringIO.new("".b)
+      encode(io)
+      io.string
+    end
+
+    private
+
+    def build_lum_qtable
+      table = @luminance_table || Quantization.scale_table(Quantization::LUMINANCE_BASE, quality)
+      table = @quantization_modifier.call(table, :luminance) if @quantization_modifier
+      table
+    end
+
+    def build_chr_qtable
+      table = @chrominance_table || Quantization.scale_table(Quantization::CHROMINANCE_BASE, @chroma_quality)
+      table = @quantization_modifier.call(table, :chrominance) if @quantization_modifier
+      table
+    end
+
+    def encode(io)
+      width = source.width
+      height = source.height
+
+      lum_qtable = build_lum_qtable
+      lum_dc = Huffman.build_table(Huffman::DC_LUMINANCE_BITS, Huffman::DC_LUMINANCE_VALUES)
+      lum_ac = Huffman.build_table(Huffman::AC_LUMINANCE_BITS, Huffman::AC_LUMINANCE_VALUES)
+      lum_huff = Huffman::Encoder.new(lum_dc, lum_ac)
+
+      if grayscale
+        scan_data = encode_grayscale(width, height, lum_qtable, lum_huff)
+        write_grayscale_jfif(io, width, height, lum_qtable, scan_data)
+      else
+        chr_qtable = build_chr_qtable
+        chr_dc = Huffman.build_table(Huffman::DC_CHROMINANCE_BITS, Huffman::DC_CHROMINANCE_VALUES)
+        chr_ac = Huffman.build_table(Huffman::AC_CHROMINANCE_BITS, Huffman::AC_CHROMINANCE_VALUES)
+        chr_huff = Huffman::Encoder.new(chr_dc, chr_ac)
+
+        scan_data = encode_color(width, height, lum_qtable, chr_qtable, lum_huff, chr_huff)
+        write_color_jfif(io, width, height, lum_qtable, chr_qtable, scan_data)
+      end
+    end
+
+    # --- Grayscale encoding ---
+
+    def encode_grayscale(width, height, qtable, huff)
+      y_data = extract_luminance(width, height)
+      padded_w = (width + 7) & ~7
+      padded_h = (height + 7) & ~7
+
+      # Reusable buffers
+      block = Array.new(64, 0.0)
+      temp  = Array.new(64, 0.0)
+      dct   = Array.new(64, 0.0)
+      qbuf  = Array.new(64, 0)
+      zbuf  = Array.new(64, 0)
+
+      bit_writer = BitWriter.new
+      prev_dc = 0
+
+      (0...padded_h).step(8) do |by|
+        (0...padded_w).step(8) do |bx|
+          extract_block_into(y_data, width, height, bx, by, block)
+          prev_dc = encode_block(block, temp, dct, qbuf, zbuf, qtable, huff, prev_dc, bit_writer)
+        end
+      end
+
+      bit_writer.flush
+      bit_writer.bytes
+    end
+
+    def write_grayscale_jfif(io, width, height, qtable, scan_data)
+      jfif = JFIFWriter.new(io, scramble_quantization: @scramble_quantization)
+      jfif.write_soi
+      jfif.write_app0
+      jfif.write_dqt(qtable, 0)
+      jfif.write_sof0(width, height, [[1, 1, 1, 0]])
+      jfif.write_dht(0, 0, Huffman::DC_LUMINANCE_BITS, Huffman::DC_LUMINANCE_VALUES)
+      jfif.write_dht(1, 0, Huffman::AC_LUMINANCE_BITS, Huffman::AC_LUMINANCE_VALUES)
+      jfif.write_sos([[1, 0, 0]])
+      jfif.write_scan_data(scan_data)
+      jfif.write_eoi
+    end
+
+    # --- Color encoding (YCbCr 4:2:0) ---
+
+    def encode_color(width, height, lum_qt, chr_qt, lum_huff, chr_huff)
+      y_data, cb_data, cr_data = extract_ycbcr(width, height)
+
+      sub_w = (width + 1) / 2
+      sub_h = (height + 1) / 2
+      cb_sub = downsample(cb_data, width, height, sub_w, sub_h)
+      cr_sub = downsample(cr_data, width, height, sub_w, sub_h)
+
+      mcu_w = (width + 15) & ~15
+      mcu_h = (height + 15) & ~15
+
+      # Reusable buffers
+      block = Array.new(64, 0.0)
+      temp  = Array.new(64, 0.0)
+      dct   = Array.new(64, 0.0)
+      qbuf  = Array.new(64, 0)
+      zbuf  = Array.new(64, 0)
+
+      bit_writer = BitWriter.new
+      prev_dc_y = 0
+      prev_dc_cb = 0
+      prev_dc_cr = 0
+
+      (0...mcu_h).step(16) do |my|
+        (0...mcu_w).step(16) do |mx|
+          # 4 luminance blocks
+          extract_block_into(y_data, width, height, mx, my, block)
+          prev_dc_y = encode_block(block, temp, dct, qbuf, zbuf, lum_qt, lum_huff, prev_dc_y, bit_writer)
+
+          extract_block_into(y_data, width, height, mx + 8, my, block)
+          prev_dc_y = encode_block(block, temp, dct, qbuf, zbuf, lum_qt, lum_huff, prev_dc_y, bit_writer)
+
+          extract_block_into(y_data, width, height, mx, my + 8, block)
+          prev_dc_y = encode_block(block, temp, dct, qbuf, zbuf, lum_qt, lum_huff, prev_dc_y, bit_writer)
+
+          extract_block_into(y_data, width, height, mx + 8, my + 8, block)
+          prev_dc_y = encode_block(block, temp, dct, qbuf, zbuf, lum_qt, lum_huff, prev_dc_y, bit_writer)
+
+          # 1 Cb block
+          extract_block_into(cb_sub, sub_w, sub_h, mx >> 1, my >> 1, block)
+          prev_dc_cb = encode_block(block, temp, dct, qbuf, zbuf, chr_qt, chr_huff, prev_dc_cb, bit_writer)
+
+          # 1 Cr block
+          extract_block_into(cr_sub, sub_w, sub_h, mx >> 1, my >> 1, block)
+          prev_dc_cr = encode_block(block, temp, dct, qbuf, zbuf, chr_qt, chr_huff, prev_dc_cr, bit_writer)
+        end
+      end
+
+      bit_writer.flush
+      bit_writer.bytes
+    end
+
+    def write_color_jfif(io, width, height, lum_qt, chr_qt, scan_data)
+      jfif = JFIFWriter.new(io, scramble_quantization: @scramble_quantization)
+      jfif.write_soi
+      jfif.write_app0
+      jfif.write_dqt(lum_qt, 0)
+      jfif.write_dqt(chr_qt, 1)
+      jfif.write_sof0(width, height, [[1, 2, 2, 0], [2, 1, 1, 1], [3, 1, 1, 1]])
+      jfif.write_dht(0, 0, Huffman::DC_LUMINANCE_BITS, Huffman::DC_LUMINANCE_VALUES)
+      jfif.write_dht(1, 0, Huffman::AC_LUMINANCE_BITS, Huffman::AC_LUMINANCE_VALUES)
+      jfif.write_dht(0, 1, Huffman::DC_CHROMINANCE_BITS, Huffman::DC_CHROMINANCE_VALUES)
+      jfif.write_dht(1, 1, Huffman::AC_CHROMINANCE_BITS, Huffman::AC_CHROMINANCE_VALUES)
+      jfif.write_sos([[1, 0, 0], [2, 1, 1], [3, 1, 1]])
+      jfif.write_scan_data(scan_data)
+      jfif.write_eoi
+    end
+
+    # --- Shared block pipeline (all buffers pre-allocated) ---
+
+    def encode_block(block, temp, dct, qbuf, zbuf, qtable, huff, prev_dc, bit_writer)
+      DCT.forward!(block, temp, dct)
+      Quantization.quantize!(dct, qtable, qbuf)
+      Zigzag.reorder!(qbuf, zbuf)
+      huff.encode_block(zbuf, prev_dc, bit_writer)
+    end
+
+    # --- Pixel extraction ---
+
+    def extract_luminance(width, height)
+      luminance = Array.new(width * height)
+      height.times do |y|
+        row = y * width
+        width.times do |x|
+          pixel = source[x, y]
+          luminance[row + x] = (0.299 * pixel.r + 0.587 * pixel.g + 0.114 * pixel.b).round.clamp(0, 255)
+        end
+      end
+      luminance
+    end
+
+    def extract_ycbcr(width, height)
+      size = width * height
+      y_data  = Array.new(size)
+      cb_data = Array.new(size)
+      cr_data = Array.new(size)
+
+      height.times do |py|
+        row = py * width
+        width.times do |px|
+          pixel = source[px, py]
+          r = pixel.r; g = pixel.g; b = pixel.b
+          i = row + px
+          y_data[i]  = ( 0.299    * r + 0.587    * g + 0.114    * b).round.clamp(0, 255)
+          cb_data[i] = (-0.168736 * r - 0.331264 * g + 0.5      * b + 128.0).round.clamp(0, 255)
+          cr_data[i] = ( 0.5      * r - 0.418688 * g - 0.081312 * b + 128.0).round.clamp(0, 255)
+        end
+      end
+
+      [y_data, cb_data, cr_data]
+    end
+
+    def downsample(data, src_w, src_h, dst_w, dst_h)
+      out = Array.new(dst_w * dst_h)
+      max_x = src_w - 1
+      max_y = src_h - 1
+      dst_h.times do |dy|
+        sy = dy << 1
+        y1 = sy < max_y ? sy + 1 : max_y
+        row0 = sy * src_w
+        row1 = y1 * src_w
+        dst_row = dy * dst_w
+        dst_w.times do |dx|
+          sx = dx << 1
+          x1 = sx < max_x ? sx + 1 : max_x
+          out[dst_row + dx] = ((data[row0 + sx] + data[row0 + x1] +
+                                data[row1 + sx] + data[row1 + x1]) >> 2)
+        end
+      end
+      out
+    end
+
+    # Extract an 8x8 block into a pre-allocated array, level-shifted by -128.
+    def extract_block_into(channel, width, height, bx, by, block)
+      max_x = width - 1
+      max_y = height - 1
+      8.times do |row|
+        sy = by + row
+        sy = max_y if sy > max_y
+        src_row = sy * width
+        row8 = row << 3
+        8.times do |col|
+          sx = bx + col
+          sx = max_x if sx > max_x
+          block[row8 | col] = channel[src_row + sx] - 128.0
+        end
+      end
+      block
+    end
+  end
+end

data/lib/pure_jpeg/huffman/decoder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PureJPEG
+  module Huffman
+    class DecodeTable
+      def initialize(bits, values)
+        @min_code = Array.new(17, 0)
+        @max_code = Array.new(17, -1)
+        @val_ptr = Array.new(17, 0)
+        @values = values
+
+        code = 0
+        k = 0
+        16.times do |i|
+          len = i + 1
+          @val_ptr[len] = k
+          if bits[i] > 0
+            @min_code[len] = code
+            code += bits[i]
+            @max_code[len] = code - 1
+            k += bits[i]
+          end
+          code <<= 1
+        end
+      end
+
+      # Decode one Huffman symbol from the bit reader.
+      def decode(reader)
+        code = 0
+        1.upto(16) do |len|
+          code = (code << 1) | reader.read_bit
+          if @max_code[len] >= 0 && code <= @max_code[len]
+            return @values[@val_ptr[len] + code - @min_code[len]]
+          end
+        end
+        raise "Invalid Huffman code"
+      end
+    end
+  end
+end

data/lib/pure_jpeg/huffman/encoder.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module PureJPEG
+  module Huffman
+    class Encoder
+      def initialize(dc_table, ac_table)
+        @dc_table = dc_table
+        @ac_table = ac_table
+      end
+
+      # Encode a single 8x8 block (in zigzag order, quantized).
+      # `prev_dc` is the DC value of the previous block (for DPCM).
+      # Writes encoded bits to `writer` (a BitWriter).
+      # Returns the current block's DC value.
+      def encode_block(zigzag, prev_dc, writer)
+        dc = zigzag[0]
+        diff = dc - prev_dc
+        encode_dc(diff, writer)
+        encode_ac(zigzag, writer)
+        dc
+      end
+
+      private
+
+      def encode_dc(diff, writer)
+        cat, bits = category_and_bits(diff)
+        code, length = @dc_table[cat]
+        writer.write_bits(code, length)
+        writer.write_bits(bits, cat) if cat > 0
+      end
+
+      def encode_ac(zigzag, writer)
+        last_nonzero = 63
+        last_nonzero -= 1 while last_nonzero > 0 && zigzag[last_nonzero] == 0
+
+        if last_nonzero == 0 && zigzag[0] == zigzag[0]  # AC starts at index 1
+          # All AC coefficients are zero
+          eob = @ac_table[0x00]
+          writer.write_bits(eob[0], eob[1])
+          return
+        end
+
+        i = 1
+        while i <= last_nonzero
+          run = 0
+          while i <= last_nonzero && zigzag[i] == 0
+            run += 1
+            i += 1
+          end
+
+          # Emit ZRL (16 zeros) symbols as needed
+          while run >= 16
+            zrl = @ac_table[0xF0]
+            writer.write_bits(zrl[0], zrl[1])
+            run -= 16
+          end
+
+          cat, bits = category_and_bits(zigzag[i])
+          symbol = (run << 4) | cat
+          code, length = @ac_table[symbol]
+          writer.write_bits(code, length)
+          writer.write_bits(bits, cat) if cat > 0
+          i += 1
+        end
+
+        # EOB if we didn't reach position 63
+        if last_nonzero < 63
+          eob = @ac_table[0x00]
+          writer.write_bits(eob[0], eob[1])
+        end
+      end
+
+      # Returns [category, encoded_bits] for a coefficient value.
+      def category_and_bits(value)
+        return [0, 0] if value == 0
+        abs_val = value.abs
+        cat = 0
+        v = abs_val
+        while v > 0
+          cat += 1
+          v >>= 1
+        end
+        bits = value > 0 ? value : value + (1 << cat) - 1
+        [cat, bits]
+      end
+    end
+  end
+end

data/lib/pure_jpeg/huffman/tables.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PureJPEG
+  module Huffman
+    # Standard Huffman tables from JPEG Annex K.
+    # Each table is defined by bits (number of codes of each length 1-16)
+    # and values (the symbol for each code, in order).
+
+    DC_LUMINANCE_BITS   = [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0].freeze
+    DC_LUMINANCE_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].freeze
+
+    AC_LUMINANCE_BITS = [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7D].freeze
+    AC_LUMINANCE_VALUES = [
+      0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
+      0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
+      0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
+      0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
+      0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
+      0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
+      0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+      0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+      0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+      0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+      0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+      0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+      0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
+      0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
+      0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
+      0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
+      0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
+      0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
+      0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
+      0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
+      0xF9, 0xFA
+    ].freeze
+
+    DC_CHROMINANCE_BITS   = [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0].freeze
+    DC_CHROMINANCE_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].freeze
+
+    AC_CHROMINANCE_BITS = [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77].freeze
+    AC_CHROMINANCE_VALUES = [
+      0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
+      0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
+      0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+      0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
+      0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
+      0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
+      0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
+      0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
+      0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+      0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
+      0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
+      0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+      0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
+      0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
+      0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
+      0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
+      0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
+      0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
+      0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
+      0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
+      0xF9, 0xFA
+    ].freeze
+
+    # Build a lookup table: symbol -> [code, code_length]
+    # from the bits/values specification.
+    def self.build_table(bits, values)
+      table = {}
+      code = 0
+      k = 0
+
+      16.times do |i|
+        bits[i].times do
+          table[values[k]] = [code, i + 1]
+          k += 1
+          code += 1
+        end
+        code <<= 1
+      end
+
+      table
+    end
+  end
+end

data/lib/pure_jpeg/image.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module PureJPEG
+  # A decoded JPEG image with pixel-level access.
+  #
+  # Implements the same pixel source interface (+width+, +height+, +[x, y]+)
+  # as encoder inputs, so a decoded image can be passed directly to
+  # {PureJPEG.encode} for re-encoding.
+  class Image
+    # @return [Integer] image width in pixels
+    attr_reader :width
+    # @return [Integer] image height in pixels
+    attr_reader :height
+
+    # @param width [Integer]
+    # @param height [Integer]
+    # @param pixels [Array<Source::Pixel>] flat row-major array of pixels
+    def initialize(width, height, pixels)
+      @width = width
+      @height = height
+      @pixels = pixels
+    end
+
+    # Retrieve a pixel by coordinate.
+    #
+    # @param x [Integer] column (0-based)
+    # @param y [Integer] row (0-based)
+    # @return [Source::Pixel] pixel with +.r+, +.g+, +.b+ in 0-255
+    def [](x, y)
+      @pixels[y * @width + x]
+    end
+
+    # Set a pixel by coordinate.
+    #
+    # @param x [Integer] column (0-based)
+    # @param y [Integer] row (0-based)
+    # @param pixel [Source::Pixel] replacement pixel
+    # @return [Source::Pixel]
+    def []=(x, y, pixel)
+      @pixels[y * @width + x] = pixel
+    end
+
+    # Iterate over every pixel in the image.
+    #
+    # @yieldparam x [Integer] column
+    # @yieldparam y [Integer] row
+    # @yieldparam pixel [Source::Pixel] the pixel at (x, y)
+    # @return [void]
+    def each_pixel
+      @height.times do |y|
+        @width.times do |x|
+          yield x, y, self[x, y]
+        end
+      end
+    end
+  end
+end