png_conform 0.1.0

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG ENDL (End loop) chunks
+      #
+      # The ENDL chunk marks the end of a loop started by a LOOP chunk.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 1 byte
+      # - Nesting level must match corresponding LOOP
+      # - Must have corresponding LOOP before it
+      # - Must appear before MEND
+      class EndlValidator < BaseValidator
+        EXPECTED_LENGTH = 1
+
+        def validate
+          return false unless check_crc
+          return false unless check_length(EXPECTED_LENGTH)
+
+          unless context.retrieve(:mhdr_present)
+            add_error("ENDL must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("ENDL must appear before MEND")
+            return false
+          end
+
+          unless context.retrieve(:loop_present)
+            add_error("ENDL must appear after LOOP")
+            return false
+          end
+
+          # Nesting level (1 byte)
+          nesting_level = chunk.chunk_data.getbyte(0)
+
+          # Validate loop nesting
+          loop_stack = context.retrieve(:loop_stack) || []
+
+          if loop_stack.empty?
+            add_error("ENDL without corresponding LOOP")
+            return false
+          elsif loop_stack.last != nesting_level
+            add_error(
+              "ENDL nesting level (#{nesting_level}) does not match " \
+              "LOOP nesting level (#{loop_stack.last})",
+            )
+            return false
+          else
+            loop_stack.pop
+            context.store(:loop_stack, loop_stack)
+          end
+
+          context.store(:endl_nesting_level, nesting_level)
+          context.store(:endl_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG FRAM (Frame parameters) chunks
+      #
+      # The FRAM chunk sets frame parameters including framing mode, subframe
+      # name, change interframe delay, change timeout, change layer clipping,
+      # and change sync ID.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length can be 0, 1, or variable (with parameters)
+      # - Framing mode: 0-4
+      # - All parameters optional based on change flags
+      # - Must appear before MEND
+      class FramValidator < BaseValidator
+        VALID_FRAMING_MODES = (0..4).to_a.freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("FRAM must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("FRAM must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          # Empty FRAM is valid
+          if data.empty?
+            context.store(:fram_present, true)
+            return true
+          end
+
+          pos = 0
+
+          # Framing mode (1 byte)
+          if pos < data.length
+            framing_mode = data.getbyte(pos)
+            pos += 1
+
+            unless VALID_FRAMING_MODES.include?(framing_mode)
+              add_error(
+                "Invalid FRAM framing mode: #{framing_mode} (must be 0-4)",
+              )
+              return false
+            end
+
+            context.store(:fram_framing_mode, framing_mode)
+          end
+
+          # Parse optional change flags and parameters
+          if pos < data.length
+            # Subframe name length (1 byte) + name
+            name_length = data.getbyte(pos)
+            pos += 1
+
+            if pos + name_length > data.length
+              add_error("FRAM subframe name extends beyond chunk")
+              return false
+            end
+
+            if name_length.positive?
+              subframe_name = data[pos, name_length]
+              pos += name_length
+              context.store(:fram_subframe_name, subframe_name)
+            end
+          end
+
+          # Remaining parameters are change flags and their values
+          # We don't need to parse all of them in detail for basic validation
+          # Just ensure the chunk length is reasonable
+          if pos < data.length
+            # Store that FRAM has parameters
+            context.store(:fram_has_parameters, true)
+          end
+
+          context.store(:fram_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG LOOP (Loop control) chunks
+      #
+      # The LOOP chunk marks the beginning of a loop in an MNG animation.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 5 or 6 bytes
+      # - Nesting level must be >= 0
+      # - Iteration count must be >= 0 (0 = infinite)
+      # - Must have corresponding ENDL
+      # - Must appear before MEND
+      class LoopValidator < BaseValidator
+        VALID_LENGTHS = [5, 6].freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("LOOP must appear after MHDR")
+            return false
+          end
+
+          data = chunk.chunk_data
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "LOOP chunk must be 5 or 6 bytes, got #{data.length}",
+            )
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("LOOP must appear before MEND")
+            return false
+          end
+
+          # Nesting level (1 byte)
+          nesting_level = data.getbyte(0)
+
+          # Iteration count (4 bytes)
+          iteration_count = data[1, 4].unpack1("N")
+
+          context.store(:loop_nesting_level, nesting_level)
+          context.store(:loop_iteration_count, iteration_count)
+
+          if data.length == 6
+            # Termination condition (1 byte)
+            termination = data.getbyte(5)
+
+            unless (0..3).cover?(termination)
+              add_error(
+                "LOOP termination condition must be 0-3, got #{termination}",
+              )
+              return false
+            end
+
+            context.store(:loop_termination, termination)
+          end
+
+          # Track loop nesting
+          loop_stack = context.retrieve(:loop_stack) || []
+          loop_stack.push(nesting_level)
+          context.store(:loop_stack, loop_stack)
+
+          context.store(:loop_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validator for MEND (MNG End) chunk
+      #
+      # The MEND chunk marks the end of a MNG datastream.
+      # It must be the last chunk in the file and contains no data.
+      #
+      class MendValidator < BaseValidator
+        CHUNK_TYPE = "MEND"
+        EXPECTED_LENGTH = 0
+
+        def validate
+          return false unless check_crc
+          return false unless check_length(EXPECTED_LENGTH)
+
+          # MEND must have MHDR before it
+          unless context.seen?("MHDR")
+            add_error("MEND requires MHDR chunk")
+            return false
+          end
+
+          # MEND should be last chunk (this will be validated by orchestration)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validator for MHDR (MNG Header) chunk
+      #
+      # The MHDR chunk is the first chunk in a MNG datastream and contains
+      # basic information about the MNG file.
+      #
+      # Structure (28 bytes):
+      # - frame_width (4 bytes): Frame width in pixels
+      # - frame_height (4 bytes): Frame height in pixels
+      # - ticks_per_second (4 bytes): Nominal tick rate
+      # - nominal_layer_count (4 bytes): Nominal layer count
+      # - nominal_frame_count (4 bytes): Nominal frame count
+      # - nominal_play_time (4 bytes): Nominal play time
+      # - simplicity_profile (4 bytes): Simplicity profile flags
+      #
+      class MhdrValidator < BaseValidator
+        CHUNK_TYPE = "MHDR"
+        EXPECTED_LENGTH = 28
+
+        def validate
+          return false unless check_crc
+          return false unless check_length(EXPECTED_LENGTH)
+
+          # MHDR must be first chunk
+          unless context.chunks_seen.empty?
+            add_error("MHDR must be the first chunk in MNG file")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          # Extract fields
+          frame_width = data[0..3].unpack1("N")
+          frame_height = data[4..7].unpack1("N")
+          ticks_per_second = data[8..11].unpack1("N")
+          nominal_layer_count = data[12..15].unpack1("N")
+          nominal_frame_count = data[16..19].unpack1("N")
+          nominal_play_time = data[20..23].unpack1("N")
+          simplicity_profile = data[24..27].unpack1("N")
+
+          # Validate dimensions
+          valid = true
+          if frame_width.zero? || frame_height.zero?
+            add_error("MHDR frame dimensions must be > 0")
+            valid = false
+          end
+
+          if valid
+            # Store in context
+            context.store(:mhdr_frame_width, frame_width)
+            context.store(:mhdr_frame_height, frame_height)
+            context.store(:mhdr_ticks_per_second, ticks_per_second)
+            context.store(:mhdr_nominal_layer_count, nominal_layer_count)
+            context.store(:mhdr_nominal_frame_count, nominal_frame_count)
+            context.store(:mhdr_nominal_play_time, nominal_play_time)
+            context.store(:mhdr_simplicity_profile, simplicity_profile)
+            context.store(:mhdr_present, true)
+          end
+
+          valid
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG MOVE (Move object) chunks
+      #
+      # The MOVE chunk moves an object to a new location.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Must appear before MEND
+      # - Length must be 13 bytes
+      # - Contains first object ID, last object ID, move type, and X/Y offsets
+      class MoveValidator < BaseValidator
+        EXPECTED_LENGTH = 13
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("MOVE must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("MOVE must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          unless data.length == EXPECTED_LENGTH
+            add_error(
+              "MOVE chunk must be #{EXPECTED_LENGTH} bytes, " \
+              "got #{data.length}",
+            )
+            return false
+          end
+
+          # Parse MOVE data
+          # First object ID (2 bytes)
+          # Last object ID (2 bytes)
+          # Move type (1 byte)
+          # X offset (4 bytes, signed)
+          # Y offset (4 bytes, signed)
+          first_id, last_id, move_type, x_offset, y_offset =
+            data.unpack("nnCl>l>")
+
+          context.store(:move_first_id, first_id)
+          context.store(:move_last_id, last_id)
+          context.store(:move_type, move_type)
+          context.store(:move_x_offset, x_offset)
+          context.store(:move_y_offset, y_offset)
+          context.store(:move_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG SAVE (Save state) chunks
+      #
+      # The SAVE chunk saves the current MNG state for later restoration with SEEK.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 0 bytes (empty)
+      # - Must appear before MEND
+      class SaveValidator < BaseValidator
+        EXPECTED_LENGTH = 0
+
+        def validate
+          return false unless check_crc
+          return false unless check_length(EXPECTED_LENGTH)
+
+          # Must appear after MHDR
+          unless context.retrieve(:mhdr_present)
+            add_error("SAVE must appear after MHDR")
+            return false
+          end
+
+          # Must appear before MEND
+          if context.seen?("MEND")
+            add_error("SAVE must appear before MEND")
+            return false
+          end
+
+          context.store(:save_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG SEEK (Seek to saved state) chunks
+      #
+      # The SEEK chunk restores the MNG state previously saved with SAVE.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 0 bytes (empty)
+      # - Should have corresponding SAVE before it
+      # - Must appear before MEND
+      class SeekValidator < BaseValidator
+        EXPECTED_LENGTH = 0
+
+        def validate
+          return false unless check_crc
+          return false unless check_length(EXPECTED_LENGTH)
+
+          unless context.retrieve(:mhdr_present)
+            add_error("SEEK must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("SEEK must appear before MEND")
+            return false
+          end
+
+          unless context.retrieve(:save_present)
+            add_warning("SEEK without corresponding SAVE")
+          end
+
+          context.store(:seek_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG SHOW (Show object) chunks
+      #
+      # The SHOW chunk makes a previously defined object visible.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Must appear before MEND
+      # - Length must be 0 or 2 bytes
+      # - If 2 bytes, contains object ID to show
+      class ShowValidator < BaseValidator
+        VALID_LENGTHS = [0, 2].freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("SHOW must appear after MHDR")
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("SHOW must appear before MEND")
+            return false
+          end
+
+          data = chunk.chunk_data
+
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "SHOW chunk must be 0 or 2 bytes, got #{data.length}",
+            )
+            return false
+          end
+
+          if data.length == 2
+            # Object ID (2 bytes)
+            object_id = data.unpack1("n")
+            context.store(:show_object_id, object_id)
+          end
+
+          context.store(:show_present, true)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PngConform
+  module Validators
+    module Mng
+      # Validates MNG TERM (Termination action) chunks
+      #
+      # The TERM chunk specifies the action to take when the animation terminates.
+      #
+      # Validation rules:
+      # - Must appear after MHDR
+      # - Length must be 1 or 10 bytes
+      # - Termination action: 0-3
+      # - Action after iterations: 0-2
+      # - Must appear before MEND
+      class TermValidator < BaseValidator
+        VALID_LENGTHS = [1, 10].freeze
+        VALID_TERMINATION_ACTIONS = (0..3).to_a.freeze
+        VALID_AFTER_ITERATIONS = (0..2).to_a.freeze
+
+        def validate
+          return false unless check_crc
+
+          unless context.retrieve(:mhdr_present)
+            add_error("TERM must appear after MHDR")
+            return false
+          end
+
+          data = chunk.chunk_data
+          unless VALID_LENGTHS.include?(data.length)
+            add_error(
+              "TERM chunk must be 1 or 10 bytes, got #{data.length}",
+            )
+            return false
+          end
+
+          if context.seen?("MEND")
+            add_error("TERM must appear before MEND")
+            return false
+          end
+
+          # Termination action (1 byte)
+          termination_action = data.getbyte(0)
+
+          unless VALID_TERMINATION_ACTIONS.include?(termination_action)
+            add_error(
+              "Invalid TERM termination action: #{termination_action} " \
+              "(must be 0-3)",
+            )
+            return false
+          end
+
+          context.store(:term_termination_action, termination_action)
+
+          if data.length == 10
+            # Action after iterations (1 byte)
+            after_iterations = data.getbyte(1)
+
+            unless VALID_AFTER_ITERATIONS.include?(after_iterations)
+              add_error(
+                "Invalid TERM action after iterations: #{after_iterations} " \
+                "(must be 0-2)",
+              )
+              return false
+            end
+
+            # Delay (4 bytes)
+            delay = data[2, 4].unpack1("N")
+
+            # Maximum iterations (4 bytes)
+            max_iterations = data[6, 4].unpack1("N")
+
+            context.store(:term_after_iterations, after_iterations)
+            context.store(:term_delay, delay)
+            context.store(:term_max_iterations, max_iterations)
+          end
+
+          context.store(:term_present, true)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/png_conform/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PngConform
+  VERSION = "0.1.0"
+end