png_conform 0.1.0

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG sCAL (Physical Scale) chunk
+      #
+      # sCAL specifies the physical scale of the image:
+      # - Unit specifier (1 byte)
+      # - Pixel width (null-terminated ASCII floating point)
+      # - Pixel height (null-terminated ASCII floating point)
+      #
+      # Validation rules from PNG spec:
+      # - Unit must be 1 (meters) or 2 (radians)
+      # - Width and height must be valid ASCII floating point numbers
+      # - Width and height must be positive
+      # - Must appear before IDAT chunk
+      # - Only one sCAL chunk allowed
+      class ScalValidator < BaseValidator
+        # Valid unit specifiers
+        UNIT_METER = 1
+        UNIT_RADIAN = 2
+        VALID_UNITS = [UNIT_METER, UNIT_RADIAN].freeze
+
+        # Unit names for display
+        UNIT_NAMES = {
+          UNIT_METER => "meter",
+          UNIT_RADIAN => "radian",
+        }.freeze
+
+        # ASCII floating point regex (simple form)
+        FLOAT_REGEX = /\A[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\z/
+
+        # Validate sCAL chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_uniqueness
+          return false unless check_position
+          return false unless check_structure
+          return false unless check_unit
+          return false unless check_dimensions
+
+          store_scale_info
+          true
+        end
+
+        private
+
+        # Check that only one sCAL chunk exists
+        def check_uniqueness
+          if context.seen?("sCAL") || context.retrieve(:has_scale)
+            add_error("duplicate sCAL chunk (only one allowed)")
+            return false
+          end
+
+          true
+        end
+
+        # Check that sCAL appears before IDAT
+        def check_position
+          if context.seen?("IDAT")
+            add_error("sCAL chunk after IDAT chunk")
+            return false
+          end
+
+          true
+        end
+
+        # Check sCAL chunk structure
+        def check_structure
+          data = chunk.chunk_data
+
+          # Must contain at least unit + width + null + height + null
+          if data.length < 5
+            add_error("sCAL chunk too short (minimum 5 bytes)")
+            return false
+          end
+
+          # Must contain two null separators
+          nulls = data.bytes.each_index.select { |i| data[i] == "\0" }
+          if nulls.length < 2
+            add_error("sCAL chunk missing null separators " \
+                      "(found #{nulls.length}, need 2)")
+            return false
+          end
+
+          true
+        end
+
+        # Check unit specifier
+        def check_unit
+          data = chunk.chunk_data
+          unit = data[0].ord
+
+          unless VALID_UNITS.include?(unit)
+            add_error("sCAL invalid unit specifier (#{unit}, " \
+                      "must be 1 or 2)")
+            return false
+          end
+
+          true
+        end
+
+        # Check dimension strings
+        def check_dimensions
+          data = chunk.chunk_data
+          first_null = data.index("\0", 1)
+          second_null = data.index("\0", first_null + 1)
+
+          width_str = data[1, first_null - 1]
+          height_str = data[(first_null + 1), second_null - first_null - 1]
+
+          # Check width
+          unless valid_float_string?(width_str)
+            add_error("sCAL invalid width format: '#{width_str}'")
+            return false
+          end
+
+          width = width_str.to_f
+          unless width.positive?
+            add_error("sCAL width must be positive (got #{width})")
+            return false
+          end
+
+          # Check height
+          unless valid_float_string?(height_str)
+            add_error("sCAL invalid height format: '#{height_str}'")
+            return false
+          end
+
+          height = height_str.to_f
+          unless height.positive?
+            add_error("sCAL height must be positive (got #{height})")
+            return false
+          end
+
+          true
+        end
+
+        # Validate floating point string format
+        def valid_float_string?(str)
+          return false if str.empty?
+          return false unless str.match?(FLOAT_REGEX)
+
+          # Additional check: must be finite
+          value = str.to_f
+          value.finite?
+        end
+
+        # Store scale information in context
+        def store_scale_info
+          data = chunk.chunk_data
+          unit = data[0].ord
+          first_null = data.index("\0", 1)
+          second_null = data.index("\0", first_null + 1)
+
+          width_str = data[1, first_null - 1]
+          height_str = data[(first_null + 1), second_null - first_null - 1]
+
+          width = width_str.to_f
+          height = height_str.to_f
+          unit_name = UNIT_NAMES[unit]
+
+          # Store in context
+          context.store(:has_scale, true)
+          context.store(:scale_width, width)
+          context.store(:scale_height, height)
+          context.store(:scale_unit, unit)
+
+          # Add info about the scale
+          add_info("sCAL: #{width} x #{height} #{unit_name}s per pixel")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG sPLT (Suggested Palette) chunk
+      #
+      # sPLT suggests a reduced palette for quantization:
+      # - Palette name (1-79 bytes, Latin-1)
+      # - Null separator (1 byte)
+      # - Sample depth (1 byte, 8 or 16)
+      # - Palette entries (6 or 10 bytes each):
+      #   * Red (1 or 2 bytes)
+      #   * Green (1 or 2 bytes)
+      #   * Blue (1 or 2 bytes)
+      #   * Alpha (1 or 2 bytes)
+      #   * Frequency (2 bytes)
+      #
+      # Validation rules from PNG spec:
+      # - Palette name must be 1-79 characters, Latin-1 printable
+      # - Palette name must not have leading/trailing/consecutive spaces
+      # - Sample depth must be 8 or 16
+      # - Number of entries must be exact (no partial entries)
+      # - Must appear before IDAT chunk
+      # - Multiple sPLT chunks allowed with different names
+      class SpltValidator < BaseValidator
+        # Maximum palette name length
+        MAX_PALETTE_NAME_LENGTH = 79
+
+        # Latin-1 printable characters (space to tilde + high ASCII)
+        PRINTABLE_LATIN1 = (32..126).to_a + (161..255).to_a
+
+        # Valid sample depths
+        VALID_SAMPLE_DEPTHS = [8, 16].freeze
+
+        # Entry sizes by sample depth
+        ENTRY_SIZE_8BIT = 6 # RGBA (1 byte each) + frequency (2 bytes)
+        ENTRY_SIZE_16BIT = 10 # RGBA (2 bytes each) + frequency (2 bytes)
+
+        # Validate sPLT chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_position
+          return false unless check_structure
+          return false unless check_palette_name
+          return false unless check_sample_depth
+          return false unless check_entries
+
+          store_palette_info
+          true
+        end
+
+        private
+
+        # Check that sPLT appears before IDAT
+        def check_position
+          if context.seen?("IDAT")
+            add_error("sPLT chunk after IDAT chunk")
+            return false
+          end
+
+          true
+        end
+
+        # Check sPLT chunk structure
+        def check_structure
+          data = chunk.chunk_data
+
+          # Must contain at least name + null + sample depth
+          if data.length < 3
+            add_error("sPLT chunk too short (minimum 3 bytes)")
+            return false
+          end
+
+          # Must contain null separator
+          null_pos = data.index("\0")
+          unless null_pos
+            add_error("sPLT chunk missing null separator")
+            return false
+          end
+
+          true
+        end
+
+        # Check palette name validity
+        def check_palette_name
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          palette_name = data[0, null_pos]
+
+          # Check palette name length
+          if palette_name.empty?
+            add_error("sPLT chunk has empty palette name")
+            return false
+          end
+
+          if palette_name.length > MAX_PALETTE_NAME_LENGTH
+            add_error("sPLT palette name too long (#{palette_name.length}, " \
+                      "max #{MAX_PALETTE_NAME_LENGTH})")
+            return false
+          end
+
+          # Check for Latin-1 printable characters
+          palette_name.bytes.each do |byte|
+            next if PRINTABLE_LATIN1.include?(byte)
+
+            add_error("sPLT palette name contains non-printable " \
+                      "character (0x#{byte.to_s(16)})")
+            return false
+          end
+
+          # Check for leading/trailing spaces
+          if palette_name.start_with?(" ")
+            add_error("sPLT palette name has leading space")
+            return false
+          end
+
+          if palette_name.end_with?(" ")
+            add_error("sPLT palette name has trailing space")
+            return false
+          end
+
+          # Check for consecutive spaces
+          if palette_name.include?("  ")
+            add_error("sPLT palette name has consecutive spaces")
+            return false
+          end
+
+          true
+        end
+
+        # Check sample depth
+        def check_sample_depth
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          sample_depth = data[null_pos + 1].ord
+
+          unless VALID_SAMPLE_DEPTHS.include?(sample_depth)
+            add_error("sPLT invalid sample depth (#{sample_depth}, " \
+                      "must be 8 or 16)")
+            return false
+          end
+
+          true
+        end
+
+        # Check palette entries
+        def check_entries
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          sample_depth = data[null_pos + 1].ord
+          entries_data = data[(null_pos + 2)..] || ""
+
+          # Determine entry size
+          entry_size = sample_depth == 8 ? ENTRY_SIZE_8BIT : ENTRY_SIZE_16BIT
+
+          # Check that entries data is exact multiple of entry size
+          if (entries_data.length % entry_size) != 0
+            add_error("sPLT entries data length (#{entries_data.length}) " \
+                      "not a multiple of entry size (#{entry_size})")
+            return false
+          end
+
+          # Check minimum entries (at least 1)
+          num_entries = entries_data.length / entry_size
+          if num_entries.zero?
+            add_error("sPLT chunk has no palette entries")
+            return false
+          end
+
+          true
+        end
+
+        # Store suggested palette information in context
+        def store_palette_info
+          data = chunk.chunk_data
+          null_pos = data.index("\0")
+          palette_name = data[0, null_pos]
+          sample_depth = data[null_pos + 1].ord
+          entries_data = data[(null_pos + 2)..] || ""
+
+          # Calculate number of entries
+          entry_size = sample_depth == 8 ? ENTRY_SIZE_8BIT : ENTRY_SIZE_16BIT
+          num_entries = entries_data.length / entry_size
+
+          # Parse entries and find frequency range
+          frequencies = []
+          (0...num_entries).each do |i|
+            offset = i * entry_size
+            freq_offset = offset + (entry_size - 2)
+            freq = (entries_data[freq_offset].ord << 8) |
+              entries_data[freq_offset + 1].ord
+            frequencies << freq
+          end
+
+          # Store in context (allow multiple sPLT chunks)
+          palettes = context.retrieve(:suggested_palettes) || []
+          palettes << {
+            name: palette_name,
+            sample_depth: sample_depth,
+            num_entries: num_entries,
+            frequencies: frequencies,
+          }
+          context.store(:suggested_palettes, palettes)
+
+          # Add info about the suggested palette
+          max_freq = frequencies.max || 0
+          min_freq = frequencies.min || 0
+          total_freq = frequencies.sum
+
+          add_info("sPLT: \"#{palette_name}\" " \
+                   "(#{num_entries} entries, #{sample_depth}-bit, " \
+                   "frequency range #{min_freq}-#{max_freq}, " \
+                   "total #{total_freq})")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG sRGB (Standard RGB Color Space) chunk
+      #
+      # sRGB indicates that the image uses the sRGB color space:
+      # - Rendering intent (1 byte):
+      #   0 = Perceptual
+      #   1 = Relative colorimetric
+      #   2 = Saturation
+      #   3 = Absolute colorimetric
+      #
+      # Validation rules from PNG spec:
+      # - Must be exactly 1 byte
+      # - Must appear before PLTE and IDAT
+      # - Only one sRGB chunk allowed
+      # - Rendering intent must be 0-3
+      # - If both sRGB and gAMA present, gAMA should be 45455 (gamma 2.2)
+      # - If both sRGB and cHRM present, values should match sRGB
+      class SrgbValidator < BaseValidator
+        # Rendering intents
+        INTENT_PERCEPTUAL = 0
+        INTENT_RELATIVE_COLORIMETRIC = 1
+        INTENT_SATURATION = 2
+        INTENT_ABSOLUTE_COLORIMETRIC = 3
+
+        INTENT_NAMES = {
+          INTENT_PERCEPTUAL => "perceptual",
+          INTENT_RELATIVE_COLORIMETRIC => "relative colorimetric",
+          INTENT_SATURATION => "saturation",
+          INTENT_ABSOLUTE_COLORIMETRIC => "absolute colorimetric",
+        }.freeze
+
+        # Expected gamma for sRGB (45455 = 2.2)
+        SRGB_GAMMA = 45_455
+
+        # Validate sRGB chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_length(1)
+          return false unless check_position
+          return false unless check_uniqueness
+          return false unless check_intent
+
+          check_gamma_consistency
+
+          store_srgb_info
+          true
+        end
+
+        private
+
+        # Check sRGB position relative to other chunks
+        def check_position
+          valid = true
+
+          # sRGB should appear before PLTE and IDAT
+          if context.seen?("PLTE")
+            add_warning("sRGB chunk after PLTE (should be before)")
+          end
+
+          if context.seen?("IDAT")
+            add_error("sRGB chunk after IDAT (must be before)")
+            valid = false
+          end
+
+          valid
+        end
+
+        # Check that only one sRGB chunk is present
+        def check_uniqueness
+          if context.seen?("sRGB")
+            add_error("duplicate sRGB chunk")
+            return false
+          end
+          true
+        end
+
+        # Check rendering intent
+        def check_intent
+          intent = chunk.chunk_data.unpack1("C")
+          check_enum(intent, INTENT_NAMES.keys, "rendering intent")
+        end
+
+        # Check consistency with gAMA chunk if present
+        def check_gamma_consistency
+          return unless context.seen?("gAMA")
+
+          gamma = context.retrieve(:gamma)
+          return unless gamma
+
+          return unless gamma != SRGB_GAMMA
+
+          actual_gamma = gamma / 100_000.0
+          add_warning("sRGB chunk present but gAMA is #{actual_gamma} " \
+                      "(should be 2.2 for sRGB)")
+        end
+
+        # Store sRGB information in context
+        def store_srgb_info
+          intent = chunk.chunk_data.unpack1("C")
+          context.store(:srgb_intent, intent)
+          context.store(:uses_srgb, true)
+
+          intent_name = INTENT_NAMES[intent]
+          add_info("sRGB: #{intent_name} rendering intent")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Ancillary
+      # Validator for PNG sTER (Stereo Image Indicator) chunk
+      #
+      # sTER indicates that the image is part of a stereo image pair:
+      # - Mode (1 byte)
+      #
+      # Validation rules from PNG spec:
+      # - Chunk must be exactly 1 byte
+      # - Mode must be 0 (cross-fuse) or 1 (diverging-fuse)
+      # - Must appear before IDAT chunk
+      # - Only one sTER chunk allowed
+      class SterValidator < BaseValidator
+        # Expected chunk length
+        EXPECTED_LENGTH = 1
+
+        # Valid stereo modes
+        MODE_CROSS_FUSE = 0
+        MODE_DIVERGING_FUSE = 1
+        VALID_MODES = [MODE_CROSS_FUSE, MODE_DIVERGING_FUSE].freeze
+
+        # Mode names for display
+        MODE_NAMES = {
+          MODE_CROSS_FUSE => "cross-fuse layout",
+          MODE_DIVERGING_FUSE => "diverging-fuse layout",
+        }.freeze
+
+        # Validate sTER chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_uniqueness
+          return false unless check_position
+          return false unless check_length
+          return false unless check_mode
+
+          store_stereo_info
+          true
+        end
+
+        private
+
+        # Check that only one sTER chunk exists
+        def check_uniqueness
+          if context.retrieve(:has_stereo)
+            add_error("Multiple sTER chunks (only one allowed)")
+            return false
+          end
+
+          true
+        end
+
+        # Check that sTER appears before IDAT
+        def check_position
+          if context.seen?("IDAT")
+            add_error("sTER chunk after IDAT chunk")
+            return false
+          end
+
+          true
+        end
+
+        # Check chunk length
+        def check_length
+          actual_length = chunk.chunk_data.length
+
+          unless actual_length == EXPECTED_LENGTH
+            add_error("sTER chunk wrong length (#{actual_length} byte(s), " \
+                      "expected #{EXPECTED_LENGTH})")
+            return false
+          end
+
+          true
+        end
+
+        # Check stereo mode
+        def check_mode
+          data = chunk.chunk_data
+          mode = data[0].ord
+
+          unless VALID_MODES.include?(mode)
+            add_error("sTER invalid mode (#{mode}, must be 0 or 1)")
+            return false
+          end
+
+          true
+        end
+
+        # Store stereo information in context
+        def store_stereo_info
+          data = chunk.chunk_data
+          mode = data[0].ord
+          mode_name = MODE_NAMES[mode]
+
+          # Store in context
+          context.store(:has_stereo, true)
+          context.store(:stereo_mode, mode)
+
+          # Add info about the stereo mode
+          add_info("sTER: #{mode_name} (mode #{mode})")
+        end
+      end
+    end
+  end
+end