png_conform 0.1.0

data/lib/png_conform/validators/jng/jdat_validator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Jng
+      # Validates JNG JDAT (JPEG image data) chunks
+      #
+      # The JDAT chunk contains JPEG-compressed image data. Multiple JDAT chunks
+      # may be present in a JNG file and must be concatenated in sequence to
+      # form the complete JPEG datastream.
+      #
+      # Validation rules:
+      # - Must appear after JHDR
+      # - Contains JPEG compressed data
+      # - Multiple JDAT chunks allowed (concatenated in sequence)
+      # - Must appear before IEND
+      class JdatValidator < BaseValidator
+        # Validate JDAT chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+
+          valid = true
+
+          # JDAT must appear after JHDR
+          unless context.retrieve(:jhdr_present)
+            add_error("JDAT must appear after JHDR")
+            valid = false
+          end
+
+          # JDAT must appear before IEND
+          if context.seen?("IEND")
+            add_error("JDAT must appear before IEND")
+            valid = false
+          end
+
+          # Check minimum length (at least 1 byte of JPEG data)
+          data = chunk.chunk_data
+          if data.empty?
+            add_error("JDAT chunk too short (#{data.length} bytes, " \
+                      "minimum 1)")
+            valid = false
+          end
+
+          if valid
+            # Store JDAT count for tracking
+            jdat_count = context.retrieve(:jdat_count) || 0
+            context.store(:jdat_count, jdat_count + 1)
+
+            # Track total JDAT data length
+            total_jdat_length = context.retrieve(:jdat_data_length) || 0
+            context.store(:jdat_data_length, total_jdat_length + data.length)
+          end
+
+          # NOTE: We don't validate JPEG structure here - that would require
+          # JPEG parsing which is beyond the scope of JNG chunk validation
+
+          valid
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/jng/jhdr_validator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Jng
+      # Validator for JHDR (JNG Header) chunk
+      #
+      # The JHDR chunk is the first chunk in a JNG (JPEG Network Graphics)
+      # datastream and contains information about the JPEG image.
+      #
+      # Structure (16 bytes):
+      # - width (4 bytes): Image width in pixels
+      # - height (4 bytes): Image height in pixels
+      # - color_type (1 byte): Color type (8, 10, 12, 14)
+      # - image_sample_depth (1 byte): JPEG sample depth (8 or 12)
+      # - image_compression_method (1 byte): JPEG compression (8)
+      # - interlace_method (1 byte): Interlace method (0)
+      # - alpha_sample_depth (1 byte): Alpha channel sample depth
+      # - alpha_compression_method (1 byte): Alpha compression method
+      # - alpha_filter_method (1 byte): Alpha filter method
+      # - alpha_interlace_method (1 byte): Alpha interlace method
+      # - 4 reserved bytes
+      #
+      class JhdrValidator < BaseValidator
+        VALID_COLOR_TYPES = [8, 10, 12, 14].freeze
+        VALID_SAMPLE_DEPTHS = [8, 12].freeze
+
+        # Validate JHDR chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_length(16)
+
+          # JHDR must be first chunk in JNG
+          unless context.chunks_seen.empty?
+            add_error("JHDR must be the first chunk in JNG datastream")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          # Extract fields
+          width = data[0, 4].unpack1("N")
+          height = data[4, 4].unpack1("N")
+          color_type = data[8].unpack1("C")
+          image_sample_depth = data[9].unpack1("C")
+          image_compression = data[10].unpack1("C")
+          interlace = data[11].unpack1("C")
+
+          valid = true
+
+          # Validate dimensions
+          valid &= check_dimensions(width, height)
+
+          # Validate color type
+          valid &= check_enum(color_type, VALID_COLOR_TYPES, "color type")
+
+          # Validate sample depth
+          valid &= check_enum(image_sample_depth, VALID_SAMPLE_DEPTHS,
+                              "image sample depth")
+
+          # Validate compression method (must be 8 for baseline JPEG)
+          if image_compression != 8
+            add_error("invalid image compression method (#{image_compression}, " \
+                      "must be 8)")
+            valid = false
+          end
+
+          # Validate interlace method (must be 0)
+          if interlace != 0
+            add_error("invalid interlace method (#{interlace}, must be 0)")
+            valid = false
+          end
+
+          if valid
+            store_jhdr_info(width, height, color_type,
+                            image_sample_depth)
+          end
+
+          valid
+        end
+
+        private
+
+        # Check image dimensions
+        def check_dimensions(width, height)
+          valid = true
+
+          if width.zero?
+            add_error("invalid image width (0)")
+            valid = false
+          end
+
+          if height.zero?
+            add_error("invalid image height (0)")
+            valid = false
+          end
+
+          valid
+        end
+
+        # Store JHDR information in context for use by other validators
+        def store_jhdr_info(width, height, color_type, image_sample_depth)
+          context.store(:jhdr_width, width)
+          context.store(:jhdr_height, height)
+          context.store(:jhdr_color_type, color_type)
+          context.store(:jhdr_image_sample_depth, image_sample_depth)
+          context.store(:jhdr_present, true)
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/jng/jsep_validator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../base_validator"
+
+module PngConform
+  module Validators
+    module Jng
+      # Validates JNG JSEP (8-bit/12-bit image separator) chunks
+      #
+      # The JSEP chunk separates 8-bit and 12-bit JPEG image data in a JNG file.
+      # It is only present when the sample depth is 12 bits and both 8-bit and
+      # 12-bit JPEG data are included.
+      #
+      # Validation rules:
+      # - Must appear after JHDR
+      # - Length must be 0 (no data)
+      # - Only valid when sample depth is 12 bits
+      # - Separates 8-bit JDAT chunks from 12-bit JDAT chunks
+      # - Must appear before IEND
+      class JsepValidator < BaseValidator
+        # Validate JSEP chunk
+        #
+        # @return [Boolean] True if validation passed
+        def validate
+          return false unless check_crc
+          return false unless check_length(0)
+
+          valid = true
+
+          # JSEP must appear after JHDR
+          unless context.retrieve(:jhdr_present)
+            add_error("JSEP must appear after JHDR")
+            valid = false
+          end
+
+          # JSEP must appear before IEND
+          if context.seen?("IEND")
+            add_error("JSEP must appear before IEND")
+            valid = false
+          end
+
+          # JSEP is only valid with 12-bit sample depth
+          sample_depth = context.retrieve(:jhdr_image_sample_depth)
+          if sample_depth && sample_depth != 12
+            add_error("JSEP is only valid with 12-bit sample depth, " \
+                      "got #{sample_depth}-bit")
+            valid = false
+          end
+
+          # JSEP should appear after at least one JDAT (8-bit data)
+          # and before the 12-bit JDAT chunks
+          unless context.retrieve(:jdat_count).to_i.positive?
+            add_warning("JSEP should appear after 8-bit JDAT chunks")
+          end
+
+          if valid
+            # Mark that JSEP was seen
+            context.store(:jsep_present, true)
+          end
+
+          valid
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/mng/back_validator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG BACK (Background color) chunks
+      #
+      # The BACK chunk specifies the background color and image for the MNG
+      # frame.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Must appear before MEND
+      # - Length must be 6, 7, or 10 bytes
+      # - Mandatory background flag: 0 or 1
+      # - Tile mode: 0-3
+      class BackValidator < BaseValidator
+        VALID_LENGTHS = [6, 7, 10].freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("BACK must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("BACK must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "BACK chunk must be 6, 7, or 10 bytes, " \
+              "got #{data.length}",
+            )
+            return false
+          end
+
+          # Red, Green, Blue (2 bytes each)
+          red, green, blue = data[0, 6].unpack("nnn")
+          context.store(:back_red, red)
+          context.store(:back_green, green)
+          context.store(:back_blue, blue)
+
+          if data.length >= 7
+            # Mandatory background flag (1 byte)
+            mandatory = data.getbyte(6)
+
+            unless [0, 1].include?(mandatory)
+              add_error(
+                "BACK mandatory flag must be 0 or 1, got #{mandatory}",
+              )
+              return false
+            end
+
+            context.store(:back_mandatory, mandatory)
+          end
+
+          if data.length == 10
+            # Background image ID (2 bytes)
+            bg_image_id = data[7, 2].unpack1("n")
+
+            # Background tile mode (1 byte)
+            tile_mode = data.getbyte(9)
+
+            unless (0..3).cover?(tile_mode)
+              add_error(
+                "BACK tile mode must be 0-3, got #{tile_mode}",
+              )
+              return false
+            end
+
+            context.store(:back_image_id, bg_image_id)
+            context.store(:back_tile_mode, tile_mode)
+          end
+
+          context.store(:back_present, true)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/mng/clip_validator.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG CLIP (Clip object) chunks
+      #
+      # The CLIP chunk defines clipping boundaries for subsequent objects.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Must appear before MEND
+      # - Length must be 21 bytes
+      # - Contains first/last object IDs, clip type, and clipping boundaries
+      class ClipValidator < BaseValidator
+        EXPECTED_LENGTH = 21
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("CLIP must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("CLIP must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          unless data.length == EXPECTED_LENGTH
+            add_error(
+              "CLIP chunk must be #{EXPECTED_LENGTH} bytes, " \
+              "got #{data.length}",
+            )
+            return false
+          end
+
+          # Parse CLIP data
+          # First object ID (2 bytes)
+          # Last object ID (2 bytes)
+          # Clip type (1 byte)
+          # Left delta (4 bytes, signed)
+          # Right delta (4 bytes, signed)
+          # Top delta (4 bytes, signed)
+          # Bottom delta (4 bytes, signed)
+          first_id, last_id, clip_type, left, right, top, bottom =
+            data.unpack("nnCl>l>l>l>")
+
+          context.store(:clip_first_id, first_id)
+          context.store(:clip_last_id, last_id)
+          context.store(:clip_type, clip_type)
+          context.store(:clip_left, left)
+          context.store(:clip_right, right)
+          context.store(:clip_top, top)
+          context.store(:clip_bottom, bottom)
+          context.store(:clip_present, true)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/mng/clon_validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG CLON (Clone object) chunks
+      #
+      # The CLON chunk creates a copy of an existing object.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 4 or 16 bytes
+      # - Must appear before MEND
+      class ClonValidator < BaseValidator
+        VALID_LENGTHS = [4, 16].freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("CLON must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("CLON must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "CLON chunk must be 4 or 16 bytes, got #{data.length}",
+            )
+            return false
+          end
+
+          context.store(:clon_present, true)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/mng/defi_validator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG DEFI (Object definition) chunks
+      #
+      # The DEFI chunk defines an object and its location within the MNG frame.
+      # It specifies the object ID, clipping boundaries, and concrete flag.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 2, 3, 4, 12, or 28 bytes
+      # - Object ID >= 0
+      # - Clipping boundaries must be valid if specified
+      # - Must appear before MEND
+      class DefiValidator < BaseValidator
+        VALID_LENGTHS = [2, 3, 4, 12, 28].freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("DEFI must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("DEFI must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "DEFI chunk must be 2, 3, 4, 12, or 28 bytes, " \
+              "got #{data.length}",
+            )
+            return false
+          end
+
+          pos = 0
+
+          # Object ID (2 bytes)
+          object_id = data.unpack1("n")
+          pos += 2
+          context.store(:defi_object_id, object_id)
+
+          if data.length >= 3
+            # Do-not-show flag (1 byte)
+            do_not_show = data.getbyte(pos)
+            pos += 1
+            context.store(:defi_do_not_show, do_not_show)
+          end
+
+          if data.length >= 4
+            # Concrete flag (1 byte)
+            concrete = data.getbyte(pos)
+            pos += 1
+            context.store(:defi_concrete, concrete)
+          end
+
+          if data.length >= 12
+            # X and Y location (4 bytes each)
+            x_location, y_location = data[pos, 8].unpack("NN")
+            pos += 8
+            context.store(:defi_x_location, x_location)
+            context.store(:defi_y_location, y_location)
+          end
+
+          if data.length == 28
+            # Clipping boundaries (4 x 4 bytes)
+            left, right, top, bottom = data[pos, 16].unpack("NNNN")
+
+            # Validate clipping boundaries
+            if left > right
+              add_error(
+                "DEFI left clipping (#{left}) must not exceed " \
+                "right clipping (#{right})",
+              )
+              return false
+            end
+
+            if top > bottom
+              add_error(
+                "DEFI top clipping (#{top}) must not exceed " \
+                "bottom clipping (#{bottom})",
+              )
+              return false
+            end
+
+            context.store(:defi_clip_left, left)
+            context.store(:defi_clip_right, right)
+            context.store(:defi_clip_top, top)
+            context.store(:defi_clip_bottom, bottom)
+          end
+
+          context.store(:defi_present, true)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/mng/dhdr_validator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG DHDR (Delta-PNG header) chunks
+      #
+      # The DHDR chunk marks the beginning of an embedded delta-PNG (difference
+      # image) in an MNG file. It has a similar structure to IHDR but is used
+      # for delta frames.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 4, 12, or 20 bytes
+      # - Object ID must be >= 0
+      # - Image type: 0 (PNG), 2 (JNG), or 4 (PNG with alpha separation)
+      # - Delta type: 0 (entire replacement), 1-7 (various delta types)
+      # - Block width/height must be > 0 if specified
+      class DhdrValidator < BaseValidator
+        VALID_LENGTHS = [4, 12, 20].freeze
+        VALID_IMAGE_TYPES = [0, 2, 4].freeze
+        VALID_DELTA_TYPES = (0..7).to_a.freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("DHDR must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("DHDR must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "DHDR chunk must be 4, 12, or 20 bytes, " \
+              "got #{data.length}",
+            )
+            return false
+          end
+
+          values = data.unpack("N*")
+
+          # All formats have object ID
+          object_id = values[0]
+          context.store(:dhdr_object_id, object_id)
+
+          if data.length >= 12
+            # 12 or 20 byte format includes image type and delta type
+            image_type = values[1]
+            delta_type = values[2]
+
+            unless VALID_IMAGE_TYPES.include?(image_type)
+              add_error(
+                "Invalid DHDR image type: #{image_type} " \
+                "(must be 0, 2, or 4)",
+              )
+              return false
+            end
+
+            unless VALID_DELTA_TYPES.include?(delta_type)
+              add_error(
+                "Invalid DHDR delta type: #{delta_type} " \
+                "(must be 0-7)",
+              )
+              return false
+            end
+
+            context.store(:dhdr_image_type, image_type)
+            context.store(:dhdr_delta_type, delta_type)
+          end
+
+          if data.length == 20
+            # 20 byte format includes block dimensions
+            block_width = values[3]
+            block_height = values[4]
+
+            if block_width.zero?
+              add_error("DHDR block width must be greater than 0")
+              return false
+            end
+
+            if block_height.zero?
+              add_error("DHDR block height must be greater than 0")
+              return false
+            end
+
+            context.store(:dhdr_block_width, block_width)
+            context.store(:dhdr_block_height, block_height)
+          end
+
+          # DHDR begins a new object definition
+          context.store(:in_dhdr_section, true)
+          context.store(:dhdr_present, true)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/validators/mng/disc_validator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG DISC (Discard objects) chunks
+      #
+      # The DISC chunk discards one or more objects from the MNG object buffer.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be a multiple of 2 bytes (list of object IDs)
+      # - Must appear before MEND
+      class DiscValidator < BaseValidator
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("DISC must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("DISC must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          if data.length.odd?
+            add_error(
+              "DISC chunk length must be a multiple of 2, " \
+              "got #{data.length}",
+            )
+            return false
+          end
+
+          context.store(:disc_present, true)
+          true
+        end
+      end
+    end
+  end
+end