pure_jpeg 0.3.3 → 0.4.1

data/lib/pure_jpeg/decoder.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 module PureJPEG
-  # Baseline JPEG decoder.
+  # Baseline and progressive JPEG decoder.
   #
-  # Decodes baseline DCT (SOF0) JPEGs with 1 or 3 components, any chroma
-  # subsampling factor, and restart markers.
+  # Decodes baseline (SOF0) and progressive (SOF2) 8-bit grayscale/YCbCr
+  # JPEGs, including separate component scans and restart markers.
   #
   # Use {PureJPEG.read} for a convenient entry point.
   class Decoder
@@ -13,7 +13,7 @@ module PureJPEG
     # @param path_or_data [String] a file path or raw JPEG bytes
     # @return [Image] decoded image with pixel access
     def self.decode(path_or_data)
-      data = if path_or_data.is_a?(String) && !path_or_data.start_with?("\xFF\xD8".b) && File.exist?(path_or_data)
+      data = if path_or_data.is_a?(String) && !path_or_data.b.include?("\0") && !path_or_data.b.start_with?("\xFF\xD8".b) && File.exist?(path_or_data)
                File.binread(path_or_data)
              else
                path_or_data.b
@@ -29,91 +29,74 @@ module PureJPEG
       jfif = JFIFReader.new(@data)
       @icc_profile = jfif.icc_profile
       validate_dimensions!(jfif.width, jfif.height)
+      validate_frame_and_scans!(jfif)
       return decode_progressive(jfif) if jfif.progressive
 
       width = jfif.width
       height = jfif.height
 
-      # Build Huffman decode tables
-      dc_tables = {}
-      ac_tables = {}
-      jfif.huffman_tables.each do |(table_class, table_id), info|
-        table = Huffman::DecodeTable.new(info[:bits], info[:values])
-        if table_class == 0
-          dc_tables[table_id] = table
-        else
-          ac_tables[table_id] = table
-        end
-      end
-
-      # Map component IDs to their info
       comp_info = {}
       jfif.components.each { |c| comp_info[c.id] = c }
-
-      # Determine max sampling factors
       max_h = jfif.components.map(&:h_sampling).max
       max_v = jfif.components.map(&:v_sampling).max
-
-      # MCU dimensions in pixels
       mcu_px_w = max_h * 8
       mcu_px_h = max_v * 8
       mcus_x = (width + mcu_px_w - 1) / mcu_px_w
       mcus_y = (height + mcu_px_h - 1) / mcu_px_h
 
-      # Allocate channel buffers (full padded size)
-      padded_w = mcus_x * mcu_px_w
-      padded_h = mcus_y * mcu_px_h
       channels = {}
       jfif.components.each do |c|
-        ch_w = (padded_w * c.h_sampling) / max_h
-        ch_h = (padded_h * c.v_sampling) / max_v
+        ch_w = mcus_x * c.h_sampling * 8
+        ch_h = mcus_y * c.v_sampling * 8
         channels[c.id] = { data: Array.new(ch_w * ch_h, 0), width: ch_w, height: ch_h }
       end
-
-      # Decode scan data
-      reader = BitReader.new(jfif.scan_data)
-      prev_dc = Hash.new(0)
-      restart_interval = jfif.restart_interval
-      mcu_count = 0
-
-      # Reusable buffers
       zigzag = Array.new(64, 0)
-      raster = Array.new(64, 0)
       dequant = Array.new(64, 0)
 
-      mcus_y.times do |mcu_row|
-        mcus_x.times do |mcu_col|
-          # Handle restart interval
-          if restart_interval > 0 && mcu_count > 0 && (mcu_count % restart_interval) == 0
-            reader.reset
-            prev_dc.clear
-          end
-
-          jfif.scan_components.each do |sc|
-            comp, dc_tab, ac_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables)
-            qt = fetch_quant_table!(jfif, comp)
-            ch = channels[comp.id]
+      jfif.scans.each do |scan|
+        dc_tables, ac_tables = build_decode_tables(scan)
+        reader = BitReader.new(scan.data)
+        prev_dc = Hash.new(0)
+        restart_interval = scan.restart_interval
+        mcu_count = 0
+        interleaved = scan.components.length > 1
+        scan_components = scan.components.map do |sc|
+          comp, dc_tab, ac_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables)
+          [sc, comp, dc_tab, ac_tab, fetch_quant_table!(jfif, comp), channels[comp.id]]
+        end
+        if interleaved
+          scan_width = mcus_x
+          scan_height = mcus_y
+        else
+          comp = scan_components[0][1]
+          scan_width = (width * comp.h_sampling + mcu_px_w - 1) / mcu_px_w
+          scan_height = (height * comp.v_sampling + mcu_px_h - 1) / mcu_px_h
+        end
 
-            comp.v_sampling.times do |bv|
-              comp.h_sampling.times do |bh|
-                # Decode one 8x8 block
-                decode_block(reader, dc_tab, ac_tab, prev_dc, sc.id, zigzag)
-
-                # Inverse pipeline: unzigzag -> dequantize -> IDCT -> level shift
-                Zigzag.unreorder!(zigzag, raster)
-                Quantization.dequantize!(raster, qt, dequant)
-                DCT.inverse!(dequant)
-
-                # Write block into channel buffer
-                bx = (mcu_col * comp.h_sampling + bh) * 8
-                by = (mcu_row * comp.v_sampling + bv) * 8
-                write_block(dequant, ch[:data], ch[:width], bx, by)
+        scan_height.times do |mcu_row|
+          scan_width.times do |mcu_col|
+            if restart_interval > 0 && mcu_count > 0 && (mcu_count % restart_interval) == 0
+              reader.read_restart((mcu_count / restart_interval - 1) % 8)
+              prev_dc.clear
+            end
+            scan_components.each do |sc, comp, dc_tab, ac_tab, qt, ch|
+              block_rows = interleaved ? comp.v_sampling : 1
+              block_cols = interleaved ? comp.h_sampling : 1
+              block_rows.times do |bv|
+                block_cols.times do |bh|
+                  decode_block(reader, dc_tab, ac_tab, prev_dc, sc.id, zigzag)
+                  Quantization.dequantize_zigzag!(zigzag, qt, dequant)
+                  DCT.inverse!(dequant)
+                  bx = (mcu_col * block_cols + bh) * 8
+                  by = (mcu_row * block_rows + bv) * 8
+                  write_block(dequant, ch[:data], ch[:width], bx, by)
+                end
               end
             end
+            mcu_count += 1
           end
-
-          mcu_count += 1
         end
+        reader.finish_scan!
       end
 
       # Assemble pixels
@@ -129,7 +112,85 @@ module PureJPEG
 
     private
 
+    def build_decode_tables(scan)
+      dc_tables = {}
+      ac_tables = {}
+      scan.huffman_tables.each do |(table_class, table_id), info|
+        table = Huffman::DecodeTable.new(info[:bits], info[:values])
+        if table_class == 0
+          dc_tables[table_id] = table
+        else
+          ac_tables[table_id] = table
+        end
+      end
+      [dc_tables, ac_tables]
+    end
+
+    def validate_frame_and_scans!(jfif)
+      unless jfif.precision == 8
+        raise DecodeError, "Unsupported JPEG precision: #{jfif.precision}"
+      end
+      count = jfif.components.length
+      unless count == 1 || count == 3
+        raise DecodeError, "Unsupported number of components: #{count}"
+      end
+      ids = jfif.components.map(&:id)
+      if count == 3 && (jfif.adobe_transform == 0 || ids.sort == [66, 71, 82])
+        raise DecodeError, "RGB JPEG decoding is unsupported"
+      end
+      if jfif.adobe_transform && ![0, 1].include?(jfif.adobe_transform)
+        raise DecodeError, "Unsupported Adobe color transform: #{jfif.adobe_transform}"
+      end
+      raise DecodeError, "JPEG scan data not found" if jfif.scans.empty?
+
+      progression = {}
+      ids.each { |id| progression[id] = Array.new(64) }
+      jfif.scans.each do |scan|
+        scan_ids = scan.components.map(&:id)
+        if scan_ids.empty? || scan_ids.uniq.length != scan_ids.length
+          raise DecodeError, "Invalid JPEG scan components"
+        end
+        scan_ids.each do |id|
+          raise DecodeError, "Scan references unknown component id #{id}" unless progression.key?(id)
+        end
+        if scan_ids.length > 1
+          blocks = jfif.components.select { |c| scan_ids.include?(c.id) }.sum { |c| c.h_sampling * c.v_sampling }
+          raise DecodeError, "Too many blocks in JPEG MCU" if blocks > 10
+        end
+
+        ss = scan.spectral_start
+        se = scan.spectral_end
+        ah = scan.successive_high
+        al = scan.successive_low
+        if jfif.progressive
+          valid = ss <= se && se <= 63 && ah <= 13 && al <= 13 &&
+                  (ss == 0 ? se == 0 : scan_ids.length == 1) &&
+                  (ah == 0 || al == ah - 1)
+          raise DecodeError, "Invalid progressive scan parameters" unless valid
+        elsif ss != 0 || se != 63 || ah != 0 || al != 0
+          raise DecodeError, "Invalid baseline scan parameters"
+        end
+        scan_ids.each do |id|
+          state = progression[id]
+          if ss > 0 && state[0].nil?
+            raise DecodeError, "Progressive AC scan precedes DC scan"
+          end
+          ss.upto(se) do |k|
+            unless ah == 0 ? state[k].nil? : state[k] == ah
+              raise DecodeError, "Invalid JPEG scan progression"
+            end
+            state[k] = al
+          end
+        end
+      end
+      if progression.values.any? { |state| state[0].nil? }
+        raise DecodeError, "JPEG scan omits a frame component"
+      end
+      jfif.components.each { |c| fetch_quant_table!(jfif, c) }
+    end
+
     def validate_dimensions!(width, height)
+      raise DecodeError, "JPEG frame header not found" unless width && height
       raise DecodeError, "Invalid image dimensions: #{width}x#{height}" if width <= 0 || height <= 0
       raise DecodeError, "Image too large: #{width}x#{height} (max #{MAX_DIMENSION}x#{MAX_DIMENSION})" if width > MAX_DIMENSION || height > MAX_DIMENSION
     end
@@ -158,12 +219,15 @@ module PureJPEG
         bx = mcus_x * c.h_sampling
         by = mcus_y * c.v_sampling
         coeffs[c.id] = Array.new(bx * by * 64, 0)
-        comp_blocks[c.id] = [bx, by]
+        actual_bx = (width * c.h_sampling + mcu_px_w - 1) / mcu_px_w
+        actual_by = (height * c.v_sampling + mcu_px_h - 1) / mcu_px_h
+        # Interleaved scans include MCU padding; single-component scans do not.
+        # Keep the storage stride separate from the actual scan dimensions.
+        comp_blocks[c.id] = [bx, by, actual_bx, actual_by]
       end
 
-      restart_interval = jfif.restart_interval
-
       jfif.scans.each do |scan|
+        restart_interval = scan.restart_interval
         # Build Huffman tables from this scan's snapshot (tables change between scans)
         dc_tables = {}
         ac_tables = {}
@@ -189,9 +253,10 @@ module PureJPEG
           prog_scan_interleaved(reader, scan, comp_info, dc_tables, ac_tables,
                                 coeffs, comp_blocks, mcus_x, mcus_y, restart_interval, ss, se, ah, al)
         end
+        reader.finish_scan!
       end
 
-      # Reconstruct: unzigzag, dequantize, IDCT, write to channel buffers
+      # Reconstruct: unzigzag/dequantize, IDCT, write to channel buffers
       padded_w = mcus_x * mcu_px_w
       padded_h = mcus_y * mcu_px_h
       channels = {}
@@ -201,8 +266,6 @@ module PureJPEG
         channels[c.id] = { data: Array.new(ch_w * ch_h, 0), width: ch_w, height: ch_h }
       end
 
-      zigzag = Array.new(64, 0)
-      raster = Array.new(64, 0)
       dequant = Array.new(64, 0)
 
       jfif.components.each do |c|
@@ -214,10 +277,7 @@ module PureJPEG
         by_count.times do |block_y|
           bx_count.times do |block_x|
             offset = (block_y * bx_count + block_x) * 64
-            64.times { |i| zigzag[i] = coeff_buf[offset + i] }
-
-            Zigzag.unreorder!(zigzag, raster)
-            Quantization.dequantize!(raster, qt, dequant)
+            Quantization.dequantize_zigzag!(coeff_buf, qt, dequant, offset)
             DCT.inverse!(dequant)
             write_block(dequant, ch[:data], ch[:width], block_x * 8, block_y * 8)
           end
@@ -237,18 +297,20 @@ module PureJPEG
     def prog_scan_non_interleaved(reader, scan, comp_info, dc_tables, ac_tables,
                                   coeffs, comp_blocks, restart_interval, ss, se, ah, al)
       sc = scan.components[0]
-      comp, dc_tab, ac_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables, require_ac: ss > 0)
+      comp, dc_tab, ac_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables,
+                                                    require_dc: ss == 0 && ah == 0, require_ac: ss > 0)
       coeff_buf = coeffs[comp.id]
-      bx_count, by_count = comp_blocks[comp.id]
+      bx_count, _by_count, actual_bx, actual_by = comp_blocks[comp.id]
 
       prev_dc = 0
       eobrun = 0
       mcu_count = 0
 
-      by_count.times do |block_y|
-        bx_count.times do |block_x|
+      actual_by.times do |block_y|
+        actual_bx.times do |block_x|
           if restart_interval > 0 && mcu_count > 0 && (mcu_count % restart_interval) == 0
-            reader.reset
+            raise DecodeError, "Progressive EOB run crosses restart boundary" if eobrun > 0
+            reader.read_restart((mcu_count / restart_interval - 1) % 8)
             prev_dc = 0
             eobrun = 0
           end
@@ -272,6 +334,7 @@ module PureJPEG
           mcu_count += 1
         end
       end
+      raise DecodeError, "Progressive EOB run exceeds scan" if eobrun > 0
     end
 
     def prog_scan_interleaved(reader, scan, comp_info, dc_tables, ac_tables,
@@ -279,18 +342,20 @@ module PureJPEG
       prev_dc = Hash.new(0)
       mcu_count = 0
 
+      scan_components = scan.components.map do |sc|
+        comp, dc_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables,
+                                              require_dc: ah == 0, require_ac: false)
+        [sc, comp, dc_tab, coeffs[comp.id], comp_blocks[comp.id][0]]
+      end
+
       mcus_y.times do |mcu_row|
         mcus_x.times do |mcu_col|
           if restart_interval > 0 && mcu_count > 0 && (mcu_count % restart_interval) == 0
-            reader.reset
+            reader.read_restart((mcu_count / restart_interval - 1) % 8)
             prev_dc.clear
           end
 
-          scan.components.each do |sc|
-            comp, dc_tab = resolve_scan_references!(sc, comp_info, dc_tables, ac_tables, require_ac: false)
-            coeff_buf = coeffs[comp.id]
-            bx_count = comp_blocks[comp.id][0]
-
+          scan_components.each do |sc, comp, dc_tab, coeff_buf, bx_count|
             comp.v_sampling.times do |bv|
               comp.h_sampling.times do |bh|
                 block_x = mcu_col * comp.h_sampling + bh
@@ -312,7 +377,7 @@ module PureJPEG
     end
 
     def prog_dc_first(reader, dc_tab, prev_dc, coeff_buf, offset, al)
-      cat = dc_tab.decode(reader)
+      cat = dc_tab.decode_symbol(reader)
       diff = reader.receive_extend(cat)
       dc_val = prev_dc + diff
       coeff_buf[offset] = dc_val << al
@@ -328,13 +393,14 @@ module PureJPEG
 
       k = ss
       while k <= se
-        symbol = ac_tab.decode(reader)
+        symbol = ac_tab.decode_symbol(reader)
         run = (symbol >> 4) & 0x0F
         size = symbol & 0x0F
 
         if size == 0
           if run == 15
             k += 16
+            raise DecodeError, "AC run exceeds spectral band" if k > se + 1
           else
             # EOBn
             eobrun = (1 << run)
@@ -343,6 +409,7 @@ module PureJPEG
           end
         else
           k += run
+          raise DecodeError, "AC run exceeds spectral band" if k > se
           coeff_buf[offset + k] = reader.receive_extend(size) << al
           k += 1
         end
@@ -364,7 +431,7 @@ module PureJPEG
 
       k = ss
       while k <= se
-        symbol = ac_tab.decode(reader)
+        symbol = ac_tab.decode_symbol(reader)
         r = (symbol >> 4) & 0x0F
         s = symbol & 0x0F
 
@@ -372,6 +439,7 @@ module PureJPEG
         # (the value bits come before refinement bits in the bitstream)
         new_value = nil
         if s != 0
+          raise DecodeError, "Invalid progressive AC refinement symbol" unless s == 1
           new_value = reader.receive_extend(s) << al
         elsif r != 15
           # EOBn: refine remaining nonzero coefficients in this block
@@ -398,7 +466,8 @@ module PureJPEG
         end
 
         # Place new coefficient at the target zero position
-        if new_value && k <= se
+        raise DecodeError, "AC refinement run exceeds spectral band" if k > se
+        if new_value
           coeff_buf[offset + k] = new_value
         end
         k += 1
@@ -417,7 +486,7 @@ module PureJPEG
 
     def decode_block(reader, dc_tab, ac_tab, prev_dc, comp_id, out)
       # DC coefficient
-      dc_cat = dc_tab.decode(reader)
+      dc_cat = dc_tab.decode_symbol(reader)
       dc_diff = reader.receive_extend(dc_cat)
       dc_val = prev_dc[comp_id] + dc_diff
       prev_dc[comp_id] = dc_val
@@ -426,7 +495,7 @@ module PureJPEG
       # AC coefficients
       i = 1
       while i < 64
-        symbol = ac_tab.decode(reader)
+        symbol = ac_tab.decode_symbol(reader)
         if symbol == 0x00 # EOB
           while i < 64
             out[i] = 0
@@ -434,6 +503,7 @@ module PureJPEG
           end
           break
         elsif symbol == 0xF0 # ZRL (16 zeros)
+          raise DecodeError, "AC run exceeds block" if i + 16 > 64
           16.times do
             out[i] = 0
             i += 1
@@ -441,6 +511,8 @@ module PureJPEG
         else
           run = (symbol >> 4) & 0x0F
           size = symbol & 0x0F
+          raise DecodeError, "Invalid baseline AC symbol" if size == 0
+          raise DecodeError, "AC run exceeds block" if i + run >= 64
           run.times do
             out[i] = 0
             i += 1
@@ -469,12 +541,14 @@ module PureJPEG
       end
     end
 
-    def resolve_scan_references!(scan_component, comp_info, dc_tables, ac_tables, require_ac: true)
+    def resolve_scan_references!(scan_component, comp_info, dc_tables, ac_tables, require_dc: true, require_ac: true)
       comp = comp_info[scan_component.id]
       raise DecodeError, "Scan references unknown component id #{scan_component.id}" unless comp
 
       dc_tab = dc_tables[scan_component.dc_table_id]
-      raise DecodeError, "Component #{scan_component.id} references missing DC Huffman table #{scan_component.dc_table_id}" unless dc_tab
+      if require_dc && !dc_tab
+        raise DecodeError, "Component #{scan_component.id} references missing DC Huffman table #{scan_component.dc_table_id}"
+      end
 
       if require_ac
         ac_tab = ac_tables[scan_component.ac_table_id]
@@ -485,7 +559,7 @@ module PureJPEG
     end
 
     def fetch_quant_table!(jfif, comp)
-      qt = jfif.quant_tables[comp.qt_id]
+      qt = jfif.component_quant_tables[comp.id]
       raise DecodeError, "Component #{comp.id} references missing quantization table #{comp.qt_id}" unless qt
 
       qt
@@ -526,6 +600,8 @@ module PureJPEG
       cb_data = cb_ch[:data]
       cr_data = cr_ch[:data]
       y_stride = y_ch[:width]
+      y_h = y_comp.h_sampling
+      y_v = y_comp.v_sampling
       cb_stride = cb_ch[:width]
       cr_stride = cr_ch[:width]
       cb_h = cb_comp.h_sampling
@@ -537,14 +613,14 @@ module PureJPEG
 
       height.times do |py|
         dst_row = py * width
-        y_row = py * y_stride
+        y_row = ((py * y_v) / max_v) * y_stride
 
         # Chroma coordinates (nearest-neighbor upsampling)
         cb_row = ((py * cb_v) / max_v) * cb_stride
         cr_row = ((py * cr_v) / max_v) * cr_stride
 
         width.times do |px|
-          lum = y_data[y_row + px]
+          lum = y_data[y_row + (px * y_h) / max_h]
 
           cb_x = (px * cb_h) / max_h
           cr_x = (px * cr_h) / max_h

data/lib/pure_jpeg/encoder.rb

@@ -146,11 +146,9 @@ module PureJPEG
                              lum_dc_bits, lum_dc_values, lum_ac_bits, lum_ac_values)
       else
         chr_qtable = build_chr_qtable
-        y_data, cb_data, cr_data = extract_ycbcr(width, height)
+        y_data, cb_sub, cr_sub = extract_ycbcr420(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)
 
         lum_dc_bits, lum_dc_values, lum_ac_bits, lum_ac_values,
           chr_dc_bits, chr_dc_values, chr_ac_bits, chr_ac_values =
@@ -215,13 +213,12 @@ module PureJPEG
       padded_h = (height + 7) & ~7
 
       block = Array.new(64, 0)
-      qbuf  = Array.new(64, 0)
       zbuf  = Array.new(64, 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)
-          yield transform_block(block, qbuf, zbuf, qtable)
+          yield transform_block(block, zbuf, qtable)
         end
       end
     end
@@ -285,28 +282,27 @@ module PureJPEG
       mcu_h = (height + 15) & ~15
 
       block = Array.new(64, 0)
-      qbuf  = Array.new(64, 0)
       zbuf  = Array.new(64, 0)
 
       (0...mcu_h).step(16) do |my|
         (0...mcu_w).step(16) do |mx|
           extract_block_into(y_data, width, height, mx, my, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(y_data, width, height, mx + 8, my, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(y_data, width, height, mx, my + 8, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(y_data, width, height, mx + 8, my + 8, block)
-          yield :y, transform_block(block, qbuf, zbuf, lum_qt)
+          yield :y, transform_block(block, zbuf, lum_qt)
 
           extract_block_into(cb_sub, sub_w, sub_h, mx >> 1, my >> 1, block)
-          yield :cb, transform_block(block, qbuf, zbuf, chr_qt)
+          yield :cb, transform_block(block, zbuf, chr_qt)
 
           extract_block_into(cr_sub, sub_w, sub_h, mx >> 1, my >> 1, block)
-          yield :cr, transform_block(block, qbuf, zbuf, chr_qt)
+          yield :cr, transform_block(block, zbuf, chr_qt)
         end
       end
     end
@@ -331,10 +327,9 @@ module PureJPEG
 
     # --- Shared block pipeline (all buffers pre-allocated) ---
 
-    def transform_block(block, qbuf, zbuf, qtable)
+    def transform_block(block, zbuf, qtable)
       DCT.forward!(block)
-      Quantization.quantize!(block, qtable, qbuf)
-      Zigzag.reorder!(qbuf, zbuf)
+      Quantization.quantize_zigzag!(block, qtable, zbuf)
       zbuf
     end
 
@@ -392,61 +387,65 @@ module PureJPEG
       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)
+    # Convert RGB in raster order, downsampling chroma after every two rows.
+    # Keeping only two full-resolution chroma rows avoids two image-sized arrays.
+    def extract_ycbcr420(width, height)
+      y_data = Array.new(width * height)
+      sub_w = (width + 1) / 2
+      sub_h = (height + 1) / 2
+      cb_sub = Array.new(sub_w * sub_h)
+      cr_sub = Array.new(sub_w * sub_h)
+      cb_rows = Array.new(width * 2)
+      cr_rows = Array.new(width * 2)
 
       if source.respond_to?(:packed_pixels)
         packed = source.packed_pixels
         r_shift, g_shift, b_shift = packed_shifts
-        i = 0
-        size.times do
-          color = packed[i]
-          r = (color >> r_shift) & 0xFF
-          g = (color >> g_shift) & 0xFF
-          b = (color >> b_shift) & 0xFF
-          y_data[i]  = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
-          cb_data[i] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
-          cr_data[i] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
-          i += 1
-        end
-      else
-        height.times do |py|
-          row = py * width
+      end
+
+      height.times do |py|
+        row = py * width
+        chroma_row = (py & 1) * width
+        if packed
+          width.times do |px|
+            color = packed[row + px]
+            r = (color >> r_shift) & 0xFF
+            g = (color >> g_shift) & 0xFF
+            b = (color >> b_shift) & 0xFF
+            y_data[row + px] = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
+            cb_rows[chroma_row + px] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
+            cr_rows[chroma_row + px] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
+          end
+        else
           width.times do |px|
             pixel = source[px, py]
             r = pixel.r; g = pixel.g; b = pixel.b
-            i = row + px
-            y_data[i]  = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
-            cb_data[i] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
-            cr_data[i] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
+            y_data[row + px] = clamp255((FP_Y_R * r + FP_Y_G * g + FP_Y_B * b + FP_HALF) >> 16)
+            cb_rows[chroma_row + px] = clamp255((FP_CB_R * r + FP_CB_G * g + FP_CB_B * b + FP_128 + FP_HALF) >> 16)
+            cr_rows[chroma_row + px] = clamp255((FP_CR_R * r + FP_CR_G * g + FP_CR_B * b + FP_128 + FP_HALF) >> 16)
           end
         end
+
+        if py.odd? || py == height - 1
+          # For odd image heights, use row zero twice at the bottom edge.
+          downsample_chroma_rows(cb_rows, cr_rows, width, chroma_row,
+                                 cb_sub, cr_sub, sub_w, (py >> 1) * sub_w)
+        end
       end
 
-      [y_data, cb_data, cr_data]
+      [y_data, cb_sub, cr_sub]
     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
+    def downsample_chroma_rows(cb_rows, cr_rows, width, row1, cb_sub, cr_sub, sub_w, dst_row)
+      max_x = width - 1
+      sub_w.times do |dx|
+        sx = dx << 1
+        x1 = sx < max_x ? sx + 1 : max_x
+        cb_sub[dst_row + dx] = (cb_rows[sx] + cb_rows[x1] +
+                                cb_rows[row1 + sx] + cb_rows[row1 + x1]) >> 2
+        cr_sub[dst_row + dx] = (cr_rows[sx] + cr_rows[x1] +
+                                cr_rows[row1 + sx] + cr_rows[row1 + x1]) >> 2
       end
-      out
     end
 
     # Extract an 8x8 block into a pre-allocated array, level-shifted by -128.