emf 0.1.2 → 0.2.0

data/lib/emf/emr/binary/pack_plan_generate.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      # Straight-line `pack` for a PackPlan: one local per leaf, inline range
+      # checks, one Array#pack with a frozen format. It takes only symbol-keyed
+      # Hashes of known, in-range, non-nil values (nested structs as Hashes or
+      # as instances of their own class; the record's array as the plan takes
+      # it); for anything else (unknown keys, nil values, bad values) it hands
+      # the call to `pack_interpreted`, so declines and results stay the
+      # interpreter's.
+      module PackPlanGenerate
+        FALLBACK = "return pack_interpreted(attrs, size: size)"
+        private_constant :FALLBACK
+
+        private
+
+        def generate_pack
+          @gen_depth = 0
+          @gen_classes = []
+          fields = @tree.reject { |_, node| node.equal?(@array) }
+          body = fields.map { |name, node| gen_node(name, node, "attrs", "seen", "  ") }.join
+          values = (0...@leaves.size).map { |index| "v#{index}" }
+          values << "*coords" if @array
+          format = (@array ? @points_format : @format).inspect
+          # def pack(attrs, size: true)
+          #   seen = 0
+          #   <one read-and-check block per field>
+          #   return pack_interpreted(attrs, size: size) unless seen == attrs.size
+          #   v1 = <size> if size
+          #   [v0, v1, ...].pack("<frozen format>")
+          # end
+          source = <<~RUBY
+            # frozen_string_literal: true
+            def pack(attrs, size: true)
+            #{gen_exact}  seen = 0
+            #{body}#{gen_array}  #{FALLBACK} unless seen == attrs.size
+
+            #{gen_size}  [#{values.join(', ')}].pack(#{format})
+            end
+          RUBY
+          singleton_class.class_eval(source, __FILE__, __LINE__)
+        end
+
+        def gen_array
+          return "" unless @array
+
+          <<~RUBY.gsub(/^(?=.)/, "  ")
+            coords = attrs[#{@array_name.inspect}]
+            unless coords.nil?
+              seen += 1
+              coords = catch(:decline) { coords_of(coords) } or #{FALLBACK}
+            end
+            #{FALLBACK} unless v#{@count} == (coords ? coords.size / 2 : 0)
+          RUBY
+        end
+
+        def gen_size
+          bytes = @array ? " + (coords ? coords.size * #{@coord_bytes} : 0)" : ""
+          "  v#{@n_size} = #{@size}#{bytes} if size\n"
+        end
+
+        def gen_node(name, node, container, counter, indent)
+          return gen_leaf(gen_read(container, name, indent), node.index, counter, indent) if node.is_a?(PackPlan::Leaf)
+
+          sub = "h#{@gen_depth += 1}"
+          @gen_classes << node.klass
+          klass = "@gen_classes[#{@gen_classes.size - 1}]"
+          inner = node.children.map { |child, n| gen_node(child, n, sub, "#{sub}_seen", "#{indent}  ") }.join
+          "#{indent}#{sub} = #{container}[#{name.inspect}]\n" \
+            "#{indent}if #{sub}.instance_of?(#{klass})\n#{indent}  #{counter} += 1\n#{gen_from(node, sub, "#{indent}  ")}" \
+            "#{indent}else\n#{gen_hash(sub, counter, inner, indent)}#{indent}end\n"
+        end
+
+        def gen_hash(sub, counter, inner, indent)
+          "#{indent}  if #{sub}.nil? then #{sub} = {}\n" \
+            "#{indent}  elsif #{sub}.instance_of?(Hash) then #{counter} += 1\n" \
+            "#{indent}  else #{FALLBACK}\n#{indent}  end\n" \
+            "#{indent}  #{sub}_seen = 0\n#{inner}" \
+            "#{indent}  #{FALLBACK} unless #{sub}_seen == #{sub}.size\n"
+        end
+
+        # The leaves of a struct instance, read through `snapshot`.
+        def gen_from(branch, source, indent)
+          branch.children.map do |name, node|
+            if node.is_a?(PackPlan::Leaf)
+              gen_leaf("#{indent}v#{node.index} = #{source}.#{name}.snapshot\n", node.index, nil, indent)
+            else
+              gen_from(node, "#{source}.#{name}", indent)
+            end
+          end.join
+        end
+
+        def gen_read(container, name, indent) = "#{indent}v = #{container}[#{name.inspect}]\n"
+
+        def gen_leaf(read, index, counter, indent)
+          var = "v#{index}"
+          read = read.sub(/\bv = /, "#{var} = ")
+          return "#{read}#{indent}#{FALLBACK} unless #{gen_valid(var, index)}\n" unless counter
+
+          "#{read}#{indent}if #{var}.nil? then #{var} = #{@defaults[index].inspect}\n" \
+            "#{indent}elsif #{gen_valid(var, index)} then #{counter} += 1\n" \
+            "#{indent}else #{FALLBACK}\n#{indent}end\n"
+        end
+
+        def gen_valid(var, index)
+          low = @lows[index]
+          return "float32_exact?(#{var})" unless low
+
+          "#{var}.instance_of?(Integer) && #{var} >= #{low} && #{var} <= #{@highs[index]}"
+        end
+      end
+    end
+  end
+end

data/lib/emf/emr/binary/pack_plan_values.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      # Which attribute values a PackPlan takes: only those BinData stores
+      # unchanged, so the wire read back from the bytes is the wire it built.
+      module PackPlanValues
+        private
+
+        def store(values, node, value)
+          case node
+          when PackPlan::Leaf then store_leaf(values, node.index, value)
+          else store_branch(values, node, value)
+          end
+        end
+
+        def store_leaf(values, index, value)
+          low = @lows[index]
+          if low
+            return unless value.instance_of?(Integer) && value >= low && value <= @highs[index]
+          else
+            return unless float32_exact?(value)
+          end
+          values[index] = value
+        end
+
+        # A Float a float32 leaf stores unchanged: it reads back as the same
+        # bits (so not NaN, not past float32 range, not rounded).
+        def float32_exact?(value)
+          value.instance_of?(Float) && [value].pack("E") == [[value].pack("e").unpack1("e")].pack("E")
+        end
+
+        def store_branch(values, node, value)
+          if value.instance_of?(Hash)
+            value.each do |name, leaf|
+              child = node.children[name] or return false
+              next if leaf.nil?
+
+              store(values, child, leaf) or return false
+            end
+            true
+          elsif value.instance_of?(node.klass)
+            node.children.all? { |name, child| store_from(values, child, value.public_send(name)) }
+          else
+            false
+          end
+        end
+
+        def store_from(values, node, source)
+          return store_branch_from(values, node, source) if node.is_a?(PackPlan::Branch)
+
+          store_leaf(values, node.index, source.snapshot)
+        end
+
+        def store_branch_from(values, node, source)
+          node.children.all? { |name, child| store_from(values, child, source.public_send(name)) }
+        end
+
+        # Flat coordinates of an Array of {x:, y:} Hashes or points of the
+        # record's point class, all Integers in the point range; else declines.
+        # Each point is read in place: no per-point pair is allocated.
+        def coords_of(points)
+          throw :decline unless points.instance_of?(Array)
+
+          coords = []
+          points.each do |point|
+            if point.instance_of?(Hash)
+              throw :decline unless point.size == 2
+
+              x = point[:x]
+              y = point[:y]
+            elsif point.instance_of?(@point_class)
+              x = point.x.snapshot
+              y = point.y.snapshot
+            else
+              throw :decline
+            end
+            throw :decline unless in_point_range?(x) && in_point_range?(y)
+
+            coords << x << y
+          end
+          coords
+        end
+
+        def in_point_range?(value)
+          value.instance_of?(Integer) && value >= @coord_low && value <= @coord_high
+        end
+      end
+    end
+  end
+end

data/lib/emf/emr/binary/palette_body.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      class PaletteBody < String
+        def initialize(record, bytes)
+          @record = record
+          super(bytes)
+        end
+
+        def assign(bytes)
+          @record.body = bytes
+          replace(@record.body)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emr/binary/palette_entry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module Emr
+    module Binary
+      class EmrPaletteEntry < BinData::Record
+        uint8 :red
+        uint8 :green
+        uint8 :blue
+        uint8 :flags
+      end
+    end
+  end
+end
+
+BinData::RegisteredClasses.register("emr_palette_entry", Emf::Emr::Binary::EmrPaletteEntry)

data/lib/emf/emr/binary/record.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/binary/class_field_accessors"
+require "emf/emr/binary/thin_shell"
 
 module Emf
   module Emr
@@ -8,9 +10,40 @@ module Emf
       # All EMR records share an 8-byte header: uint32 iType, uint32 nSize.
       # Subclasses add their own fields after this.
       class Record < BinData::Record
+        include ThinShell
+        prepend Emf::Binary::ClassFieldAccessors
+
+        # An assignment into the bytes a shell is still made from is taken
+        # before the field is made; anything else is the generic assignment.
+        module PackedAssignment
+          private
+
+          def assign_field_at(index, val)
+            return val if (@field_objs.nil? || @field_objs[index].nil?) && packed_assign(index, val)
+
+            super
+          end
+        end
+        prepend PackedAssignment
+
         endian :little
         uint32 :i_type
         uint32 :n_size
+
+        NO_ARG = Object.new.freeze
+        private_constant :NO_ARG
+
+        # `Klass.new(**attrs)` for a fixed-layout record builds from the
+        # FastFill template; every other call shape is BinData's constructor.
+        # BinData takes at most three positionals (value, parameters,
+        # parent), named here so the hot call allocates no splat array.
+        def self.new(value = NO_ARG, parameters = NO_ARG, parent = NO_ARG, **attrs)
+          if NO_ARG.equal?(value) && !attrs.empty? && (filler = FastFill.for_class(self))
+            wire = filler.build_packed(attrs) || filler.build(attrs)
+            return wire if wire
+          end
+          super(*[value, parameters, parent].take_while { |arg| !NO_ARG.equal?(arg) }, **attrs)
+        end
       end
     end
   end

data/lib/emf/emr/binary/records/alpha_blend.rb

@@ -1,15 +1,58 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/dib_header"
 
 module Emf
   module Emr
     module Binary
       module Records
         # Stub: leading fields per MS-EMF, body captures remaining bytes.
+        # The fixed part is 108 bytes including the EMR header; the bitmap
+        # pointers are read from body without declaring fields.
         class AlphaBlend < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 108
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+
           rest :body
+
+          # Read-only accessors computed from body on each call; body starts at
+          # record offset 24, so a record offset maps to (offset - 24) in body.
+          def off_bmi_src
+            pointers(60)[0]
+          end
+
+          def cb_bmi_src
+            pointers(60)[1]
+          end
+
+          def off_bits_src
+            pointers(60)[2]
+          end
+
+          def cb_bits_src
+            pointers(60)[3]
+          end
+
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 108, after_fixed,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
+
+          private
+
+          def after_fixed
+            body.to_s.byteslice(84..).to_s
+          end
+
+          def pointers(offset)
+            body.to_s.byteslice(offset, 16).to_s.unpack("V4").map(&:to_i)
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/angle_arc.rb

@@ -10,8 +10,8 @@ module Emf
         class AngleArc < Emf::Emr::Binary::Record
           point_l :ptl_center
           uint32 :n_radius
-          float :start_angle
-          float :sweep_angle
+          float32_le :start_angle
+          float32_le :sweep_angle
         end
       end
     end

data/lib/emf/emr/binary/records/bit_blt.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/with_bounds"
+require "emf/emr/binary/dib_header"
 
 module Emf
   module Emr
@@ -16,6 +18,12 @@ module Emf
         # a fixed-length :string (NOT :rest, which would consume the
         # whole tail).
         class BitBlt < Emf::Emr::Binary::WithBounds
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 100
+          variable_buffer :bmi_bytes, offset: :off_bmi_src, length: :cb_bmi_src
+          variable_buffer :bits_bytes, offset: :off_bits_src, length: :cb_bits_src
+
           int32le :x_dest
           int32le :y_dest
           int32le :cx_dest
@@ -30,6 +38,12 @@ module Emf
           uint32le :off_bits_src
           uint32le :cb_bits_src
           rest :body
+
+          # Read-only; computed from the current fields on each call.
+          def dib_header_view
+            DibHeader.view(off_bmi_src, cb_bmi_src, 100, body,
+                           bits_offset: off_bits_src, bits_size: cb_bits_src)
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/color_correct_palette.rb

@@ -1,15 +1,69 @@
 # frozen_string_literal: true
 
 require "bindata"
+require "emf/emr/binary/variable_buffers"
 require "emf/emr/binary/record"
 
 module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
         class ColorCorrectPalette < Emf::Emr::Binary::Record
+          include Emf::Emr::Binary::VariableBuffers
+
+          fixed_layout 24
+
           rest :body
+
+          def ih_palette
+            palette_body.byteslice(0, 4).unpack1("V")
+          end
+
+          def ih_palette=(value)
+            write_palette_value(0, value)
+          end
+
+          def first_entry
+            palette_body.byteslice(4, 4).unpack1("V")
+          end
+
+          def first_entry=(value)
+            write_palette_value(4, value)
+          end
+
+          def entry_count
+            palette_body.byteslice(8, 4).unpack1("V")
+          end
+
+          def entry_count=(value)
+            write_palette_value(8, value)
+          end
+
+          def reserved
+            palette_body.byteslice(12, 4).unpack1("V")
+          end
+
+          def reserved=(value)
+            write_palette_value(12, value)
+          end
+
+          private
+
+          def palette_body
+            bytes = body.to_s
+            raise ArgumentError, "invalid color correct palette body length" if bytes.bytesize < 16
+
+            bytes
+          end
+
+          def write_palette_value(offset, value)
+            bytes = palette_body.dup
+            raise ArgumentError, "palette value must be an Integer" unless value.is_a?(Integer)
+            raise RangeError, "palette value must fit an unsigned 32-bit integer" unless (0..0xffffffff).cover?(value)
+
+            bytes[offset, 4] = [value].pack("V")
+            self.body = bytes
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/colormatch_to_target_w.rb

@@ -7,9 +7,84 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Color matching profile names and data retain their original byte spans.
         class ColorMatchToTargetW < Emf::Emr::Binary::Record
+          # Byte counts and opaque spans retain the original body layout.
           rest :body
+
+          def dw_action
+            profile_prefix.unpack1("V")
+          end
+
+          def dw_action=(value)
+            write_profile_scalar(0, value)
+          end
+
+          def dw_flags
+            profile_prefix.byteslice(4, 4).unpack1("V")
+          end
+
+          def dw_flags=(value)
+            write_profile_scalar(4, value)
+          end
+
+          def cb_name
+            profile_prefix.byteslice(8, 4).unpack1("V")
+          end
+
+          def cb_data
+            profile_prefix.byteslice(12, 4).unpack1("V")
+          end
+
+          def name_bytes
+            read_profile_bytes(16, cb_name)
+          end
+
+          def name_bytes=(value)
+            write_profile_bytes(16, cb_name, value)
+          end
+
+          def profile_bytes
+            read_profile_bytes(16 + cb_name, cb_data)
+          end
+
+          def profile_bytes=(value)
+            write_profile_bytes(16 + cb_name, cb_data, value)
+          end
+
+          private
+
+          def write_profile_scalar(offset, value)
+            raise ArgumentError, "color profile scalar must be an Integer" unless value.is_a?(Integer)
+            raise RangeError, "color profile scalar must fit an unsigned 32-bit integer" unless (0..0xFFFFFFFF).cover?(value)
+
+            write_profile_bytes(offset, 4, [value].pack("V"))
+          end
+
+          def profile_prefix
+            bytes = body.to_s
+            raise ArgumentError, "truncated color profile prefix" if bytes.bytesize < 16
+
+            bytes
+          end
+
+          def read_profile_bytes(offset, length)
+            bytes = profile_prefix
+            raise ArgumentError, "truncated color profile span" if offset + length > bytes.bytesize
+
+            bytes.byteslice(offset, length).b
+          end
+
+          def write_profile_bytes(offset, length, value)
+            read_profile_bytes(offset, length)
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "color profile value must be a String of #{length} bytes"
+            end
+
+            bytes = body.to_s.b
+            bytes[offset, length] = value.b
+            self.body = bytes
+          end
         end
       end
     end

data/lib/emf/emr/binary/records/create_colorspace.rb

@@ -7,9 +7,75 @@ module Emf
   module Emr
     module Binary
       module Records
-        # Stub: preserves full body bytes. Full layout lands with TODO 10.
+        # Logical color space fields retain their original fixed-width wire bytes.
         class CreateColorspace < Emf::Emr::Binary::Record
           rest :body
+
+          [
+            [:ih_cs, 0, "V", 4],
+            [:lcs_signature, 4, "V", 332],
+            [:lcs_version, 8, "V", 332],
+            [:lcs_size, 12, "V", 332],
+            [:color_space_type, 16, "l<", 332],
+            [:intent, 20, "l<", 332],
+            [:gamma_red, 60, "V", 332],
+            [:gamma_green, 64, "V", 332],
+            [:gamma_blue, 68, "V", 332]
+          ].each do |name, offset, format, required|
+            define_method(name) do
+              colorspace_body(required).byteslice(offset, 4).unpack1(format)
+            end
+
+            define_method("#{name}=") do |value|
+              write_colorspace_value(offset, value, format, required)
+            end
+          end
+
+          def endpoints_bytes
+            colorspace_body(332).byteslice(24, 36).b
+          end
+
+          def endpoints_bytes=(value)
+            replace_colorspace_bytes(24, 36, value, 332)
+          end
+
+          def filename_bytes
+            colorspace_body(332).byteslice(72, 260).b
+          end
+
+          def filename_bytes=(value)
+            replace_colorspace_bytes(72, 260, value, 332)
+          end
+
+          private
+
+          def colorspace_body(required)
+            bytes = body.to_s
+            raise ArgumentError, "truncated logical color space body" if bytes.bytesize < required
+
+            bytes
+          end
+
+          def write_colorspace_value(offset, value, format, required)
+            colorspace_body(required)
+            raise ArgumentError, "color space value must be an Integer" unless value.is_a?(Integer)
+
+            range = format == "l<" ? (-0x80000000..0x7fffffff) : (0..0xffffffff)
+            raise RangeError, "color space value must fit its 32-bit field" unless range.cover?(value)
+
+            replace_colorspace_bytes(offset, 4, [value].pack(format), required)
+          end
+
+          def replace_colorspace_bytes(offset, length, value, required)
+            bytes = colorspace_body(required)
+            unless value.is_a?(String) && value.bytesize == length
+              raise ArgumentError, "color space value must be a String of #{length} bytes"
+            end
+
+            replacement = bytes.b
+            replacement[offset, length] = value.b
+            self.body = replacement
+          end
         end
       end
     end