png_conform 0.1.0

data/lib/png_conform/services/zlib_validator.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module PngConform
+  module Services
+    # Service for validating zlib compressed data streams
+    #
+    # This service handles:
+    # - zlib stream decompression
+    # - Filter type validation
+    # - Scanline reconstruction
+    # - Interlacing support (Adam7)
+    # - Data integrity verification
+    #
+    # PNG uses zlib compression (RFC 1950) with deflate algorithm (RFC 1951)
+    # for IDAT chunks. The decompressed data consists of filtered scanlines
+    # that must be unfiltered to reconstruct the original image data.
+    #
+    class ZlibValidator
+      # Filter types defined in PNG specification
+      FILTER_NONE = 0
+      FILTER_SUB = 1
+      FILTER_UP = 2
+      FILTER_AVERAGE = 3
+      FILTER_PAETH = 4
+
+      VALID_FILTERS = [FILTER_NONE, FILTER_SUB, FILTER_UP,
+                       FILTER_AVERAGE, FILTER_PAETH].freeze
+
+      attr_reader :errors, :warnings, :decompressed_data
+
+      def initialize
+        @errors = []
+        @warnings = []
+        @decompressed_data = nil
+      end
+
+      # Decompress and validate zlib compressed data
+      #
+      # @param compressed_data [String] Binary compressed data
+      # @param expected_size [Integer, nil] Expected decompressed size
+      # @return [Boolean] True if validation passed
+      def decompress_and_validate(compressed_data, expected_size: nil)
+        return false if compressed_data.nil? || compressed_data.empty?
+
+        begin
+          # Decompress using zlib
+          @decompressed_data = Zlib::Inflate.inflate(compressed_data)
+
+          # Validate decompressed size if expected size provided
+          if expected_size && @decompressed_data.bytesize != expected_size
+            add_error("Decompressed size mismatch " \
+                      "(expected #{expected_size}, got #{@decompressed_data.bytesize})")
+            return false
+          end
+
+          true
+        rescue Zlib::Error => e
+          add_error("zlib decompression error: #{e.message}")
+          false
+        rescue StandardError => e
+          add_error("Unexpected error during decompression: #{e.message}")
+          false
+        end
+      end
+
+      # Validate filter bytes in scanlines
+      #
+      # @param width [Integer] Image width in pixels
+      # @param height [Integer] Image height in pixels
+      # @param bit_depth [Integer] Bits per sample
+      # @param color_type [Integer] PNG color type
+      # @param interlace_method [Integer] Interlace method (0 or 1)
+      # @return [Boolean] True if all filters are valid
+      def validate_filters(width, height, bit_depth, color_type,
+                           interlace_method)
+        return false unless @decompressed_data
+
+        bytes_per_pixel = calculate_bytes_per_pixel(bit_depth, color_type)
+
+        if interlace_method.zero?
+          validate_non_interlaced_filters(width, height, bytes_per_pixel)
+        elsif interlace_method == 1
+          validate_adam7_filters(width, height, bytes_per_pixel)
+        else
+          add_error("Invalid interlace method: #{interlace_method}")
+          false
+        end
+      end
+
+      # Check if decompressed data size matches expected size
+      #
+      # @param width [Integer] Image width
+      # @param height [Integer] Image height
+      # @param bit_depth [Integer] Bits per sample
+      # @param color_type [Integer] PNG color type
+      # @param interlace_method [Integer] Interlace method
+      # @return [Boolean] True if size matches
+      def validate_data_size(width, height, bit_depth, color_type,
+                             interlace_method)
+        return false unless @decompressed_data
+
+        expected = calculate_expected_size(width, height, bit_depth,
+                                           color_type, interlace_method)
+        actual = @decompressed_data.bytesize
+
+        if actual != expected
+          add_error("Decompressed data size mismatch " \
+                    "(expected #{expected} bytes, got #{actual} bytes)")
+          return false
+        end
+
+        true
+      end
+
+      # Get validation result
+      #
+      # @return [Hash] Validation result with status and messages
+      def result
+        {
+          valid: @errors.empty?,
+          errors: @errors,
+          warnings: @warnings,
+          decompressed_size: @decompressed_data&.bytesize,
+        }
+      end
+
+      private
+
+      def add_error(message)
+        @errors << message
+      end
+
+      def add_warning(message)
+        @warnings << message
+      end
+
+      # Calculate bytes per pixel
+      def calculate_bytes_per_pixel(bit_depth, color_type)
+        samples_per_pixel = case color_type
+                            when 0 then 1  # Grayscale
+                            when 2 then 3  # RGB
+                            when 3 then 1  # Indexed
+                            when 4 then 2  # Grayscale + Alpha
+                            when 6 then 4  # RGB + Alpha
+                            else 0
+                            end
+
+        # Bytes per pixel (rounded up)
+        ((samples_per_pixel * bit_depth + 7) / 8.0).ceil
+      end
+
+      # Calculate expected decompressed data size
+      def calculate_expected_size(width, height, bit_depth, color_type,
+                                  interlace_method)
+        bytes_per_pixel = calculate_bytes_per_pixel(bit_depth, color_type)
+
+        if interlace_method.zero?
+          # Non-interlaced: (scanline_width + 1 filter byte) * height
+          scanline_width = ((width * bit_depth * samples_for_color_type(color_type) + 7) / 8.0).ceil
+          (scanline_width + 1) * height
+        else
+          # Adam7 interlaced: calculate for all 7 passes
+          calculate_adam7_size(width, height, bytes_per_pixel)
+        end
+      end
+
+      def samples_for_color_type(color_type)
+        case color_type
+        when 0 then 1  # Grayscale
+        when 2 then 3  # RGB
+        when 3 then 1  # Indexed
+        when 4 then 2  # Grayscale + Alpha
+        when 6 then 4  # RGB + Alpha
+        else 0
+        end
+      end
+
+      # Validate filters for non-interlaced image
+      def validate_non_interlaced_filters(width, height, bytes_per_pixel)
+        offset = 0
+        scanline_width = width * bytes_per_pixel
+
+        height.times do |row|
+          break if offset >= @decompressed_data.bytesize
+
+          filter_type = @decompressed_data[offset].ord
+
+          unless VALID_FILTERS.include?(filter_type)
+            add_error("Invalid filter type #{filter_type} at scanline #{row}")
+            return false
+          end
+
+          offset += scanline_width + 1 # +1 for filter byte
+        end
+
+        true
+      end
+
+      # Validate filters for Adam7 interlaced image
+      def validate_adam7_filters(width, height, bytes_per_pixel)
+        # Adam7 interlacing uses 7 passes with different starting positions and steps
+        adam7_passes = [
+          { x_start: 0, y_start: 0, x_step: 8, y_step: 8 },
+          { x_start: 4, y_start: 0, x_step: 8, y_step: 8 },
+          { x_start: 0, y_start: 4, x_step: 4, y_step: 8 },
+          { x_start: 2, y_start: 0, x_step: 4, y_step: 4 },
+          { x_start: 0, y_start: 2, x_step: 2, y_step: 4 },
+          { x_start: 1, y_start: 0, x_step: 2, y_step: 2 },
+          { x_start: 0, y_start: 1, x_step: 1, y_step: 2 },
+        ]
+
+        offset = 0
+
+        adam7_passes.each_with_index do |pass, pass_num|
+          pass_width = ((width - pass[:x_start] + pass[:x_step] - 1) / pass[:x_step]).floor
+          pass_height = ((height - pass[:y_start] + pass[:y_step] - 1) / pass[:y_step]).floor
+
+          next if pass_width.zero? || pass_height.zero?
+
+          scanline_width = pass_width * bytes_per_pixel
+
+          pass_height.times do |row|
+            break if offset >= @decompressed_data.bytesize
+
+            filter_type = @decompressed_data[offset].ord
+
+            unless VALID_FILTERS.include?(filter_type)
+              add_error("Invalid filter type #{filter_type} " \
+                        "at pass #{pass_num}, scanline #{row}")
+              return false
+            end
+
+            offset += scanline_width + 1
+          end
+        end
+
+        true
+      end
+
+      # Calculate expected size for Adam7 interlaced image
+      def calculate_adam7_size(width, height, bytes_per_pixel)
+        adam7_passes = [
+          { x_start: 0, y_start: 0, x_step: 8, y_step: 8 },
+          { x_start: 4, y_start: 0, x_step: 8, y_step: 8 },
+          { x_start: 0, y_start: 4, x_step: 4, y_step: 8 },
+          { x_start: 2, y_start: 0, x_step: 4, y_step: 4 },
+          { x_start: 0, y_start: 2, x_step: 2, y_step: 4 },
+          { x_start: 1, y_start: 0, x_step: 2, y_step: 2 },
+          { x_start: 0, y_start: 1, x_step: 1, y_step: 2 },
+        ]
+
+        total_size = 0
+
+        adam7_passes.each do |pass|
+          pass_width = ((width - pass[:x_start] + pass[:x_step] - 1) / pass[:x_step]).floor
+          pass_height = ((height - pass[:y_start] + pass[:y_step] - 1) / pass[:y_step]).floor
+
+          next if pass_width.zero? || pass_height.zero?
+
+          scanline_width = pass_width * bytes_per_pixel
+          total_size += (scanline_width + 1) * pass_height
+        end
+
+        total_size
+      end
+    end
+  end
+end

data/lib/png_conform/validators/ancillary/bkgd_validator.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG bKGD (Background Color) chunk
+      #
+      # bKGD specifies a default background color for displaying the image:
+      # - For indexed-color: 1 byte (palette index)
+      # - For grayscale: 2 bytes (gray value)
+      # - For truecolor: 6 bytes (RGB values)
+      #
+      # Validation rules from PNG spec:
+      # - Length depends on color type
+      # - Must appear before IDAT
+      # - For indexed-color, must appear after PLTE
+      # - Only one bKGD chunk allowed
+      # - Palette index must be valid
+      class BkgdValidator < BaseValidator
+        # Validate bKGD chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_position
+          return false unless check_uniqueness
+          return false unless check_length_for_color_type
+          return false unless check_value
+
+          store_background_info
+          true
+        end
+
+        private
+
+        # Check bKGD position relative to other chunks
+        def check_position
+          valid = true
+
+          # bKGD must appear before IDAT
+          if context.seen?("IDAT")
+            add_error("bKGD chunk after IDAT (must be before)")
+            valid = false
+          end
+
+          # For indexed-color, bKGD must appear after PLTE
+          color_type = context.retrieve(:color_type)
+          if color_type == 3 && !context.seen?("PLTE")
+            add_error("bKGD chunk before PLTE for indexed-color image")
+            valid = false
+          end
+
+          valid
+        end
+
+        # Check that only one bKGD chunk is present
+        def check_uniqueness
+          if context.seen?("bKGD")
+            add_error("duplicate bKGD chunk")
+            return false
+          end
+          true
+        end
+
+        # Check bKGD length for color type
+        def check_length_for_color_type
+          color_type = context.retrieve(:color_type)
+          return true unless color_type
+
+          chunk.chunk_data.bytesize
+
+          case color_type
+          when 0, 4
+            # Grayscale or grayscale+alpha: 2 bytes
+            check_length(2)
+          when 2, 6
+            # Truecolor or truecolor+alpha: 6 bytes
+            check_length(6)
+          when 3
+            # Indexed-color: 1 byte
+            check_length(1)
+          else
+            true
+          end
+        end
+
+        # Check background value validity
+        def check_value
+          color_type = context.retrieve(:color_type)
+          return true unless color_type
+
+          data = chunk.chunk_data
+
+          case color_type
+          when 3
+            # Indexed-color: check palette index
+            index = data.unpack1("C")
+            palette_entries = context.retrieve(:palette_entries)
+
+            if palette_entries && index >= palette_entries
+              add_error("bKGD palette index (#{index}) exceeds " \
+                        "palette size (#{palette_entries})")
+              return false
+            end
+          end
+
+          true
+        end
+
+        # Store background information in context
+        def store_background_info
+          color_type = context.retrieve(:color_type)
+          data = chunk.chunk_data
+
+          case color_type
+          when 0, 4
+            # Grayscale: store gray value
+            gray = data.unpack1("n")
+            context.store(:background_gray, gray)
+            add_info("bKGD: gray = #{gray}")
+          when 2, 6
+            # Truecolor: store RGB values
+            r, g, b = data.unpack("nnn")
+            context.store(:background_color, { r: r, g: g, b: b })
+            add_info("bKGD: RGB = (#{r}, #{g}, #{b})")
+          when 3
+            # Indexed-color: store palette index
+            index = data.unpack1("C")
+            context.store(:background_index, index)
+            add_info("bKGD: palette index = #{index}")
+          end
+
+          context.store(:has_background, true)
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/ancillary/chrm_validator.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG cHRM (Primary Chromaticities and White Point) chunk
+      #
+      # cHRM specifies the chromaticity coordinates of the display primaries
+      # and white point:
+      # - White Point x (4 bytes)
+      # - White Point y (4 bytes)
+      # - Red x (4 bytes)
+      # - Red y (4 bytes)
+      # - Green x (4 bytes)
+      # - Green y (4 bytes)
+      # - Blue x (4 bytes)
+      # - Blue y (4 bytes)
+      #
+      # All values are encoded as integers representing the value * 100,000.
+      #
+      # Validation rules from PNG spec:
+      # - Must be exactly 32 bytes
+      # - Must appear before PLTE and IDAT
+      # - Only one cHRM chunk allowed
+      # - Values should be in range 0.0-0.8 (0-80000)
+      # - If sRGB present, should match sRGB values
+      class ChrmValidator < BaseValidator
+        # Standard sRGB chromaticity values (* 100000)
+        SRGB_VALUES = {
+          white_x: 31_270,
+          white_y: 32_900,
+          red_x: 64_000,
+          red_y: 33_000,
+          green_x: 30_000,
+          green_y: 60_000,
+          blue_x: 15_000,
+          blue_y: 6_000,
+        }.freeze
+
+        # Tolerance for sRGB comparison
+        SRGB_TOLERANCE = 5
+
+        # Validate cHRM chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_length(32)
+          return false unless check_position
+          return false unless check_uniqueness
+          return false unless check_values
+
+          check_srgb_consistency
+
+          store_chrm_info
+          true
+        end
+
+        private
+
+        # Check cHRM position relative to other chunks
+        def check_position
+          valid = true
+
+          # cHRM should appear before PLTE and IDAT
+          if context.seen?("PLTE")
+            add_warning("cHRM chunk after PLTE (should be before)")
+          end
+
+          if context.seen?("IDAT")
+            add_error("cHRM chunk after IDAT (must be before)")
+            valid = false
+          end
+
+          valid
+        end
+
+        # Check that only one cHRM chunk is present
+        def check_uniqueness
+          if context.seen?("cHRM")
+            add_error("duplicate cHRM chunk")
+            return false
+          end
+          true
+        end
+
+        # Check chromaticity values
+        def check_values
+          data = chunk.chunk_data
+          values = data.unpack("N8")
+
+          white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y = values
+
+          valid = true
+
+          # Check ranges (typically 0.0-0.8, or 0-80000)
+          valid &= check_chromaticity(white_x, "white point x")
+          valid &= check_chromaticity(white_y, "white point y")
+          valid &= check_chromaticity(red_x, "red x")
+          valid &= check_chromaticity(red_y, "red y")
+          valid &= check_chromaticity(green_x, "green x")
+          valid &= check_chromaticity(green_y, "green y")
+          valid &= check_chromaticity(blue_x, "blue x")
+          valid &= check_chromaticity(blue_y, "blue y")
+
+          valid
+        end
+
+        # Check individual chromaticity value
+        def check_chromaticity(value, name)
+          # Values are typically 0.0-0.8 (0-80000)
+          if value > 100_000
+            add_warning("#{name} chromaticity (#{value / 100_000.0}) " \
+                        "exceeds typical range (0.0-1.0)")
+          end
+          true
+        end
+
+        # Check consistency with sRGB chunk if present
+        def check_srgb_consistency
+          return unless context.retrieve(:uses_srgb)
+
+          data = chunk.chunk_data
+          values = data.unpack("N8")
+
+          white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y = values
+
+          mismatches = []
+          mismatches << "white point x" unless close_to?(white_x,
+                                                         SRGB_VALUES[:white_x])
+          mismatches << "white point y" unless close_to?(white_y,
+                                                         SRGB_VALUES[:white_y])
+          mismatches << "red x" unless close_to?(red_x, SRGB_VALUES[:red_x])
+          mismatches << "red y" unless close_to?(red_y, SRGB_VALUES[:red_y])
+          mismatches << "green x" unless close_to?(green_x,
+                                                   SRGB_VALUES[:green_x])
+          mismatches << "green y" unless close_to?(green_y,
+                                                   SRGB_VALUES[:green_y])
+          mismatches << "blue x" unless close_to?(blue_x, SRGB_VALUES[:blue_x])
+          mismatches << "blue y" unless close_to?(blue_y, SRGB_VALUES[:blue_y])
+
+          return unless mismatches.any?
+
+          add_warning("cHRM values don't match sRGB: #{mismatches.join(', ')}")
+        end
+
+        # Check if value is close to expected sRGB value
+        def close_to?(actual, expected)
+          (actual - expected).abs <= SRGB_TOLERANCE
+        end
+
+        # Store chromaticity information in context
+        def store_chrm_info
+          data = chunk.chunk_data
+          values = data.unpack("N8")
+
+          white_x, white_y, red_x, red_y, green_x, green_y, blue_x, blue_y = values
+
+          context.store(:chromaticity, {
+                          white_x: white_x / 100_000.0,
+                          white_y: white_y / 100_000.0,
+                          red_x: red_x / 100_000.0,
+                          red_y: red_y / 100_000.0,
+                          green_x: green_x / 100_000.0,
+                          green_y: green_y / 100_000.0,
+                          blue_x: blue_x / 100_000.0,
+                          blue_y: blue_y / 100_000.0,
+                        })
+
+          add_info("cHRM: white=(#{format('%.4f', white_x / 100_000.0)}, " \
+                   "#{format('%.4f', white_y / 100_000.0)})")
+        end
+      end
+    end
+  end
+end