emf 0.1.2 → 0.2.0

data/lib/emf/native/emf_plus_stream.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "library_path"
+require_relative "emf_plus_loader"
+require_relative "emf_plus_snapshot"
+
+module Emf
+  module Native
+    # An Emf::EmfPlus::Stream whose framing comes from the native EMF+ snapshot
+    # instead of the Ruby framer. The model is the Ruby one (Segment, typed
+    # Records, ObjectTable, editing, rebuild): each native frame's validated raw
+    # bytes are decoded by the same Records classes, so unedited output is
+    # byte-identical to the source. The native structured payloads are exposed
+    # beside it through #snapshot (frame family, normalized payload, and the
+    # object-reference diagnostics computed in Rust).
+    #
+    # Native framing follows the Ruby framer: each comment is framed on its own,
+    # a malformed header ends that comment's framing (the rest stays #unframed and
+    # the ParseError is collected), and an EMR_COMMENT whose cbData exceeds its
+    # record is clamped to the bytes it holds.
+    #
+    # .from_metafile returns nil whenever the native snapshot cannot stand in for
+    # the Ruby parse (library unavailable, a record whose typed layout the native
+    # decoder rejects where Ruby keeps an Unknown record, resource limits, or a
+    # segment layout that differs from Ruby's);
+    # the caller then uses Emf::EmfPlus::Stream.from_metafile, which keeps
+    # Ruby's error-collecting recovery. An edited stream (#with_record) keeps
+    # the Ruby model but carries no snapshot.
+    class EmfPlusStream < Emf::EmfPlus::Stream
+      SEGMENT = Emf::EmfPlus::Stream::Segment
+      LOADERS_LOCK = Mutex.new
+      private_constant :SEGMENT, :LOADERS_LOCK
+
+      attr_reader :snapshot
+
+      class << self
+        # `bytes` is the EMF file the metafile was parsed from; it is rebuilt from
+        # the metafile when omitted. `library` defaults to the configured native library.
+        def from_metafile(metafile, bytes: nil, library: LibraryPath.new.call)
+          return unless metafile.format == :emf_plus && library && !library.empty?
+
+          bytes ||= Emf::Emr::Serializer.call(metafile)
+          snapshot = EmfPlusSnapshot.new(loader(library).emf_plus_snapshot(bytes))
+          build(metafile, snapshot)
+        rescue Emf::Error
+          nil
+        end
+
+        private
+
+        def loader(library)
+          LOADERS_LOCK.synchronize { (@loaders ||= {})[library] ||= EmfPlusLoader.new(library) }
+        end
+
+        def build(metafile, snapshot)
+          comments = ruby_comment_segments(metafile)
+          return unless comments.map(&:first) == snapshot.segments.map(&:record_index)
+
+          errors = []
+          segments = comments.zip(snapshot.segments).map do |(index, payload_length), row|
+            segment(metafile, snapshot, index, row, payload_length, errors)
+          end
+          return if segments.any?(&:nil?)
+
+          new(source: metafile, segments: segments, errors: errors, digests: digests_of(metafile, segments), snapshot: snapshot)
+        end
+
+        # [comment record index, payload length] exactly as Segment.from_comment selects them.
+        def ruby_comment_segments(metafile)
+          metafile.records.each_with_index.filter_map do |record, index|
+            wire = record.wire
+            next unless wire.is_a?(Emf::Emr::Binary::Records::Comment) && wire.cb_data >= SEGMENT::IDENTIFIER.bytesize
+            next unless wire.data.b.start_with?(SEGMENT::IDENTIFIER)
+
+            [index, [wire.cb_data, wire.data.bytesize].min - SEGMENT::IDENTIFIER.bytesize]
+          end
+        end
+
+        def segment(metafile, snapshot, record_index, row, payload_length, errors)
+          return unless row.payload_length == payload_length && row.data_start == SEGMENT::IDENTIFIER.bytesize
+
+          data = metafile.records[record_index].wire.data.b
+          payload = data.byteslice(SEGMENT::IDENTIFIER.bytesize, payload_length)
+          frames = snapshot.frames.select { |frame| within?(frame, row) }
+          return unless frames.all? { |frame| spans_only?(frame, snapshot.segments, row) }
+
+          framed = frames.sum(&:frame_size)
+          return unless unframed_error(payload, framed, record_index, errors)
+
+          records = frames.map { |frame| decode(frame, row, record_index, errors) }
+          payload_end = SEGMENT::IDENTIFIER.bytesize + payload_length
+          SEGMENT.new(record_index: record_index, payload_range: SEGMENT::IDENTIFIER.bytesize...payload_end,
+                      records: records, unframed: payload.byteslice(framed..), tail: data.byteslice(payload_end..))
+        end
+
+        # Native framing stops where the Ruby framer does; the unframed remainder
+        # must raise the same ParseError there (recorded in framing order, before
+        # record decode errors). A remainder Ruby would frame disagrees: no adoption.
+        def unframed_error(payload, framed, record_index, errors)
+          return true if framed == payload.bytesize
+
+          Emf::EmfPlus::Parser.read_frame(payload, framed, record_index)
+          false
+        rescue ParseError => e
+          errors << e
+          true
+        end
+
+        def within?(frame, row)
+          frame.offset >= row.logical_start && frame.offset < row.logical_start + row.payload_length
+        end
+
+        # A frame that crosses comments is malformed for Ruby (a record cannot span
+        # comments); only a frame wholly inside one segment is adopted.
+        def spans_only?(frame, segments, row)
+          segments[frame.first_segment].equal?(row) && frame.last_segment == frame.first_segment
+        end
+
+        def decode(frame, row, record_index, errors)
+          framed = Emf::EmfPlus::Frame.new(type: frame.type, flags: frame.flags, size: frame.frame_size, data_size: frame.data_size,
+                                           data: frame.raw.byteslice(Emf::EmfPlus::Frame::HEADER_BYTES..),
+                                           offset: frame.offset - row.logical_start, comment_index: record_index)
+          Emf::EmfPlus::Records.decode(framed)
+        rescue ParseError => e
+          errors << e
+          Emf::EmfPlus::Records::Unknown.new(framed)
+        end
+
+        def digests_of(metafile, segments)
+          segments.map { |segment| Digest::SHA256.digest(metafile.records[segment.record_index].to_binary_s) }
+        end
+      end
+
+      def initialize(snapshot: nil, **arguments)
+        super(**arguments)
+        @snapshot = snapshot
+      end
+
+      # The native family (EmfPlusSnapshot::FAMILIES) of the record at `handle`, or nil once edited.
+      def native_family(handle)
+        frame = snapshot&.frames&.at(handle.stream_index)
+        frame&.family
+      end
+
+      # Object-reference problems Rust found, resolved against the same table order as #resolve.
+      def reference_diagnostics = snapshot ? snapshot.diagnostics : []
+    end
+  end
+end

data/lib/emf/native/fields.rb

@@ -0,0 +1,369 @@
+# frozen_string_literal: true
+
+require_relative "palette_fields"
+require_relative "legacy_state_fields"
+
+module Emf
+  module Native
+    module Fields
+      LAYOUTS = {
+        2 => [Emr::Binary::Records::SetMapMode, [:map_mode, nil, "V", 4]],
+        5 => [Emr::Binary::Records::SetBkMode, [:bk_mode, nil, "V", 4]],
+        6 => [Emr::Binary::Records::SetPolyFillMode, [:poly_fill_mode, nil, "V", 4]],
+        7 => [Emr::Binary::Records::SetRop2, [:rop2, nil, "V", 4]],
+        8 => [Emr::Binary::Records::SetStretchBltMode, [:stretch_mode, nil, "V", 4]],
+        9 => [Emr::Binary::Records::SetWindowExtEx, [:extent, %i[cx cy], "l<2", 8]],
+        10 => [Emr::Binary::Records::SetWindowOrgEx, [:origin, %i[x y], "l<2", 8]],
+        11 => [Emr::Binary::Records::SetViewportExtEx, [:extent, %i[cx cy], "l<2", 8]],
+        12 => [Emr::Binary::Records::SetViewportOrgEx, [:origin, %i[x y], "l<2", 8]],
+        13 => [Emr::Binary::Records::SetBrushOrgEx, [:ptl_origin, %i[x y], "l<2", 8]],
+        14 => [Emr::Binary::Records::OffsetClipRgn, [:ptl_offset, %i[x y], "l<2", 8]],
+        15 => [Emr::Binary::Records::MoveToEx, [:origin, %i[x y], "l<2", 8]],
+        16 => [Emr::Binary::Records::SetTextColor, [:color, %i[red green blue reserved], "C4", 4]],
+        17 => [Emr::Binary::Records::SetBkColor, [:color, %i[red green blue reserved], "C4", 4]],
+        18 => [Emr::Binary::Records::Ellipse, [:rcl_box, %i[left top right bottom], "l<4", 16]],
+        19 => [Emr::Binary::Records::Rectangle, [:rcl_box, %i[left top right bottom], "l<4", 16]],
+        20 => [Emr::Binary::Records::RoundRect, [:rcl_box, %i[left top right bottom], "l<4", 16], [:szl_corner, %i[cx cy], "l<2", 8]],
+        21 => [Emr::Binary::Records::SetTextAlign, [:text_align_mode, nil, "V", 4]],
+        22 => [Emr::Binary::Records::SaveDc],
+        23 => [Emr::Binary::Records::RestoreDc, [:saved_dc, nil, "l<", 4]],
+        24 => [Emr::Binary::Records::SelectObject, [:ih_object, nil, "V", 4]],
+        25 => [Emr::Binary::Records::DeleteObject, [:ih_object, nil, "V", 4]],
+        26 => [Emr::Binary::Records::SetArcDirection, [:arc_direction, nil, "V", 4]],
+        27 => [Emr::Binary::Records::BeginPath],
+        28 => [Emr::Binary::Records::EndPath],
+        29 => [Emr::Binary::Records::CloseFigure],
+        30 => [Emr::Binary::Records::FillPath, [:rcl_bounds, %i[left top right bottom], "l<4", 16]],
+        31 => [Emr::Binary::Records::StrokeAndFillPath, [:rcl_bounds, %i[left top right bottom], "l<4", 16]],
+        32 => [Emr::Binary::Records::StrokePath, [:rcl_bounds, %i[left top right bottom], "l<4", 16]],
+        33 => [Emr::Binary::Records::SelectClipPath, [:region_mode, nil, "V", 4]],
+        34 => [Emr::Binary::Records::AbortPath],
+        35 => [Emr::Binary::Records::SetPixelV, [:ptl_pixel, %i[x y], "l<2", 8], [:cr_color, %i[red green blue reserved], "C4", 4]],
+        36 => [Emr::Binary::Records::ExcludeClipRect, [:rcl_clip, %i[left top right bottom], "l<4", 16]],
+        37 => [Emr::Binary::Records::IntersectClipRect, [:rcl_clip, %i[left top right bottom], "l<4", 16]],
+        38 => [Emr::Binary::Records::CreatePen, [:ih_pen, nil, "V", 4], [:pen_style, nil, "V", 4],
+               [:width, %i[x y], "l<2", 8], [:color, %i[red green blue reserved], "C4", 4]],
+        39 => [Emr::Binary::Records::CreateBrushIndirect, [:ih_brush, nil, "V", 4], [:brush_style, nil, "V", 4],
+               [:color, %i[red green blue reserved], "C4", 4], [:brush_hatch, nil, "V", 4]],
+        40 => [Emr::Binary::Records::Arc, [:rcl_box, %i[left top right bottom], "l<4", 16],
+               [:ptl_start, %i[x y], "l<2", 8], [:ptl_end, %i[x y], "l<2", 8]],
+        41 => [Emr::Binary::Records::Chord, [:rcl_box, %i[left top right bottom], "l<4", 16],
+               [:ptl_start, %i[x y], "l<2", 8], [:ptl_end, %i[x y], "l<2", 8]],
+        42 => [Emr::Binary::Records::Pie, [:rcl_box, %i[left top right bottom], "l<4", 16],
+               [:ptl_start, %i[x y], "l<2", 8], [:ptl_end, %i[x y], "l<2", 8]],
+        43 => [Emr::Binary::Records::LineTo, [:origin, %i[x y], "l<2", 8]],
+        44 => [Emr::Binary::Records::ArcTo, [:rcl_box, %i[left top right bottom], "l<4", 16],
+               [:ptl_start, %i[x y], "l<2", 8], [:ptl_end, %i[x y], "l<2", 8]],
+        60 => [Emr::Binary::Records::ScaleViewportExtEx, [:x_num, nil, "l<", 4], [:x_denom, nil, "l<", 4],
+               [:y_num, nil, "l<", 4], [:y_denom, nil, "l<", 4]],
+        61 => [Emr::Binary::Records::ScaleWindowExtEx, [:x_num, nil, "l<", 4], [:x_denom, nil, "l<", 4],
+               [:y_num, nil, "l<", 4], [:y_denom, nil, "l<", 4]],
+        62 => [Emr::Binary::Records::SetWorldTransform, [:xform, %i[m11 m12 m21 m22 dx dy], "e6", 24]],
+        63 => [Emr::Binary::Records::ModifyWorldTransform, [:xform, %i[m11 m12 m21 m22 dx dy], "e6", 24], [:modify_mode, nil, "V", 4]],
+        64 => [Emr::Binary::Records::AngleArc, [:ptl_center, %i[x y], "l<2", 8], [:n_radius, nil, "V", 4],
+               [:start_angle, nil, "e", 4], [:sweep_angle, nil, "e", 4]],
+        65 => [Emr::Binary::Records::SetMiterLimit, [:miter_limit, nil, "e", 4]],
+        66 => [Emr::Binary::Records::SetMapperFlags, [:flags, nil, "V", 4]],
+        67 => [Emr::Binary::Records::SetMetArgn],
+        69 => [Emr::Binary::Records::FlattenPath],
+        70 => [Emr::Binary::Records::WidenPath],
+        71 => [Emr::Binary::Records::SetIcmMode, [:mode, nil, "V", 4]],
+        72 => [Emr::Binary::Records::SetLayout, [:mode, nil, "V", 4]],
+        91 => [Emr::Binary::Records::ExtFloodFill, [:start, %i[x y], "l<2", 8],
+               [:color, %i[red green blue reserved], "C4", 4], [:flood_fill_mode, nil, "V", 4]],
+        92 => [Emr::Binary::Records::SetTextJustification, [:n_break_extra, nil, "l<", 4], [:n_break_count, nil, "l<", 4]]
+      }.freeze
+
+      POINT_ARRAYS = {
+        3 => [Emr::Binary::Records::Polyline, 8, :cptl, :aptl],
+        45 => [Emr::Binary::Records::PolyBezier, 8, :cptl, :aptl],
+        46 => [Emr::Binary::Records::Polygon, 8, :cptl, :aptl],
+        47 => [Emr::Binary::Records::PolyBezierTo, 8, :cptl, :aptl],
+        48 => [Emr::Binary::Records::PolylineTo, 8, :cptl, :aptl],
+        49 => [Emr::Binary::Records::PolyBezier16, 4, :cpts, :apts],
+        50 => [Emr::Binary::Records::Polygon16, 4, :cpts, :apts],
+        51 => [Emr::Binary::Records::Polyline16, 4, :cpts, :apts],
+        52 => [Emr::Binary::Records::PolyBezierTo16, 4, :cpts, :apts],
+        53 => [Emr::Binary::Records::PolylineTo16, 4, :cpts, :apts]
+      }.freeze
+
+      def self.comment(payload, raw)
+        raise FormatError, "invalid native COMMENT payload" if payload.bytesize < 8
+
+        count = payload.unpack1("Q<")
+        raise FormatError, "invalid native typed payload length" unless payload.bytesize == 8 + count
+
+        data = payload.byteslice(8..) + (raw.byteslice((12 + count)..) || "".b)
+        [Emr::Binary::Records::Comment, { cb_data: count, data: data }]
+      end
+
+      def self.eof(payload, raw)
+        raise FormatError, "invalid native typed payload length" unless payload.bytesize == 12 && raw.bytesize >= 20
+
+        # The public Ruby wire keeps the fixed word and opaque remainder even
+        # when the native EOF model reads nSizeLast from the record's final word.
+        entries, offset, last = raw.byteslice(8, 12).unpack("V3")
+        [Emr::Binary::Records::Eof, { n_pal_entries: entries, off_pal_entries: offset, n_size_last: last, body: raw.byteslice(20..) }]
+      end
+
+      def self.point_array(payload, family)
+        klass, width, count_field, points_field = POINT_ARRAYS.fetch(family)
+        raise FormatError, "invalid native point array payload" if payload.bytesize < 24
+
+        count = payload.byteslice(16, 8).unpack1("Q<")
+        raise FormatError, "invalid native typed payload length" unless payload.bytesize == 24 + (count * width)
+
+        ResourceLimits::EmfRecords.check_count(count)
+
+        bounds = %i[left top right bottom].zip(payload.unpack("l<4")).to_h
+        format = width == 8 ? "l<*" : "s<*"
+        points = payload.byteslice(24..).unpack(format).each_slice(2).map { |x, y| { x: x, y: y } }
+        [klass, { rcl_bounds: bounds, count_field => count, points_field => points }]
+      end
+
+      MULTI_POINT_ARRAYS = {
+        54 => [Emr::Binary::Records::PolyPolyline, 8, :c_ptl_total, :aptl],
+        55 => [Emr::Binary::Records::PolyPolygon, 8, :c_ptl_total, :aptl],
+        56 => [Emr::Binary::Records::PolyPolyline16, 4, :c_pts_total, :apts],
+        57 => [Emr::Binary::Records::PolyPolygon16, 4, :c_pts_total, :apts]
+      }.freeze
+
+      def self.multi_point_array(payload, family)
+        klass, width, total_field, points_field = MULTI_POINT_ARRAYS.fetch(family)
+        raise FormatError, "invalid native multi array payload" if payload.bytesize < 32
+
+        poly_count, point_count = payload.byteslice(16, 16).unpack("Q<2")
+        counts_size = poly_count * 4
+        raise FormatError, "invalid native typed payload length" unless payload.bytesize == 32 + counts_size + (point_count * width)
+
+        ResourceLimits::EmfRecords.check_count(poly_count)
+        ResourceLimits::EmfRecords.check_count(point_count)
+
+        bounds = %i[left top right bottom].zip(payload.unpack("l<4")).to_h
+        counts = payload.byteslice(32, counts_size).unpack("V*")
+        format = width == 8 ? "l<*" : "s<*"
+        points = payload.byteslice((32 + counts_size)..).unpack(format).each_slice(2).map { |x, y| { x: x, y: y } }
+        [klass, { rcl_bounds: bounds, n_polys: poly_count, a_poly_counts: counts,
+                  total_field => point_count, points_field => points }]
+      end
+
+      POLY_DRAW = {
+        58 => [Emr::Binary::Records::PolyDraw, 8, :cptl, :aptl],
+        59 => [Emr::Binary::Records::PolyDraw16, 4, :cpts, :apts]
+      }.freeze
+
+      def self.poly_draw(payload, family)
+        klass, width, count_field, points_field = POLY_DRAW.fetch(family)
+        raise FormatError, "invalid native PolyDraw payload" if payload.bytesize < 24
+
+        count = payload.byteslice(16, 8).unpack1("Q<")
+        raise FormatError, "invalid native typed payload length" unless payload.bytesize == 24 + (count * (width + 1))
+
+        ResourceLimits::EmfRecords.check_count(count)
+
+        bounds = %i[left top right bottom].zip(payload.unpack("l<4")).to_h
+        format = width == 8 ? "l<*" : "s<*"
+        points = payload.byteslice(24, count * width).unpack(format).each_slice(2).map { |x, y| { x: x, y: y } }
+        types = payload.byteslice((24 + (count * width))..).unpack("C*")
+        [klass, { rcl_bounds: bounds, count_field => count, points_field => points, ab_types: types }]
+      end
+
+      def self.ext_text(payload, family, raw)
+        raise FormatError, "invalid native text payload length" if payload.bytesize < 104
+
+        count, dx_present, dx_count, dx_first, string_present, string_length, dx_length = payload.byteslice(60, 44).unpack("Q<VQ<V2Q<2")
+        width = family == 74 ? 1 : 2
+        expected = 104 + (count * width) + (dx_count * 4) + string_length + dx_length
+        raise FormatError, "invalid native text payload length" unless payload.bytesize == expected
+
+        options, rectangle_present = payload.byteslice(36, 8).unpack("V2")
+        text_layout!(options, rectangle_present, count, dx_present, dx_count, dx_first, string_present, string_length, dx_length)
+
+        buffers = text_parts(payload, count, width, dx_count, string_length, dx_length, string_present, dx_present)
+        buffers.reverse! if dx_first == 1
+        offsets, trailing = text_buffers(buffers, rectangle_present == 1 ? 76 : 60, raw)
+        fields = text_scalars(payload)
+        fields.merge!(n_chars: count, off_string: offsets.fetch(false, 0), f_options: options,
+                      off_dx: offsets.fetch(true, 0), trailing: trailing)
+        fields[:rcl] = %i[left top right bottom].zip(payload.byteslice(44, 16).unpack("l<4")).to_h if rectangle_present == 1
+        klass = family == 74 ? Emr::Binary::Records::ExtTextOutA : Emr::Binary::Records::ExtTextOutW
+        [klass, fields]
+      end
+
+      def self.text_scalars(payload)
+        {
+          rcl_bounds: %i[left top right bottom].zip(payload.unpack("l<4")).to_h,
+          i_graphics_mode: payload.byteslice(16, 4).unpack1("V"),
+          ex_scale: payload.byteslice(20, 4).unpack1("e"), ey_scale: payload.byteslice(24, 4).unpack1("e"),
+          ptl_reference: %i[x y].zip(payload.byteslice(28, 8).unpack("l<2")).to_h
+        }
+      end
+
+      def self.text_layout!(options, rectangle, count, dx_present, dx_count, dx_first, string_present, string_length, dx_length)
+        flags = [rectangle, dx_present, dx_first, string_present]
+        valid = flags.all? { |flag| (0..1).cover?(flag) } && rectangle == (options.nobits?(0x100) ? 1 : 0)
+        expected_dx = count * (options.nobits?(0x2000) ? 1 : 2)
+        valid &&= text_dx_valid?(dx_present, dx_count, expected_dx, dx_length, dx_first)
+        valid &&= string_present == 1 || (count.zero? && string_length.zero?)
+        raise FormatError, "invalid native text layout" unless valid
+      end
+
+      def self.text_dx_valid?(present, count, expected, padding, first)
+        present == 1 ? count == expected : [count, padding, first].all?(&:zero?)
+      end
+
+      def self.text_parts(payload, count, width, dx_count, string_length, dx_length, string_present, dx_present)
+        text_end = 104 + (count * width)
+        dx_end = text_end + (dx_count * 4)
+        [[false, string_present, payload.byteslice(104...text_end), payload.byteslice(dx_end, string_length), width],
+         [true, dx_present, payload.byteslice(text_end...dx_end), payload.byteslice(dx_end + string_length, dx_length), 4]]
+      end
+
+      def self.text_buffers(buffers, fixed, raw)
+        offsets = {}
+        trailing = "".b
+        buffers.each do |is_dx, present, bytes, padding, alignment|
+          next if present.zero?
+
+          trailing << padding
+          offset = fixed + trailing.bytesize
+          raise FormatError, "invalid native text buffer alignment" unless (offset % alignment).zero?
+
+          offsets[is_dx] = offset
+          trailing << bytes
+        end
+        consumed = fixed + trailing.bytesize
+        raise FormatError, "invalid native text record span" if consumed > raw.bytesize
+
+        [offsets, trailing + raw.byteslice(consumed..)]
+      end
+
+      def self.extended_pen(payload, raw)
+        raise FormatError, "invalid native extended pen payload" if payload.bytesize < 76
+
+        count = payload.byteslice(24, 8).unpack1("Q<")
+        info, bits, first = payload.byteslice(32, 12).unpack("V3")
+        lengths = payload.byteslice(44, 32).unpack("Q<4")
+        raise FormatError, "invalid native extended pen length" unless payload.bytesize == 76 + (count * 4) + lengths.sum
+
+        pen_layout!([info, bits, first], lengths)
+        ResourceLimits::EmfRecords.check_count(count, record_bytes: payload.bytesize)
+
+        cursor = 76 + (count * 4)
+        parts = lengths.map do |length|
+          bytes = payload.byteslice(cursor, length)
+          cursor += length
+          bytes
+        end
+        offsets, buffers = pen_buffers(parts, [info, bits], first, 52 + (count * 4), raw)
+        values = payload.unpack("V6")
+        [Emr::Binary::Records::ExtCreatePen,
+         { ih_pen: values[0], pen_style: values[1], width: values[2], brush_style: values[3],
+           color: %i[red green blue reserved].zip(payload.byteslice(16, 4).unpack("C4")).to_h,
+           brush_hatch: values[5], num_style_entries: count, style_entries: payload.byteslice(76, count * 4).unpack("V*"),
+           off_bmi: offsets[0], cb_bmi: lengths[0], off_bits: offsets[1], cb_bits: lengths[1], buffers: buffers }]
+      end
+
+      def self.pen_layout!(flags, lengths)
+        valid = flags.all? { |flag| (0..1).cover?(flag) }
+        valid &&= flags[0] == 1 || [lengths[0], lengths[2]].all?(&:zero?)
+        valid &&= flags[1] == 1 || [lengths[1], lengths[3], flags[2]].all?(&:zero?)
+        raise FormatError, "invalid native extended pen layout" unless valid
+      end
+
+      def self.pen_buffers(parts, presence, first, fixed, raw)
+        offsets = [0, 0]
+        buffers = {}
+        cursor = fixed
+        (first == 1 || presence == [0, 1] ? [1, 0] : [0, 1]).each_with_index do |kind, index|
+          prefix = index.zero? ? "first" : "second"
+          padding, bytes = parts.values_at(kind + 2, kind)
+          cursor += padding.bytesize
+          if presence[kind] == 1
+            raise FormatError, "invalid native extended pen alignment" unless (cursor % 4).zero?
+
+            # Empty buffers can retain offsets into fixed fields without consuming bytes.
+            original = raw.byteslice(12 + (kind * 8), 4).unpack1("V")
+            offsets[kind] = bytes.empty? && (8...fixed).cover?(original) ? original : cursor
+          end
+          buffers[:"#{prefix}_padding"] = padding
+          buffers[:"#{prefix}_bitmap"] = bytes
+          cursor += bytes.bytesize
+        end
+        raise FormatError, "invalid native extended pen span" if cursor > raw.bytesize
+
+        buffers[:trailing] = raw.byteslice(cursor..)
+        [offsets, buffers]
+      end
+
+      def self.region(payload, family, raw)
+        klass = [Emr::Binary::Records::FillRgn, Emr::Binary::Records::FrameRgn,
+                 Emr::Binary::Records::InvertRgn, Emr::Binary::Records::PaintRgn,
+                 Emr::Binary::Records::ExtSelectClipRgn].fetch(family - 76)
+        fixed = { 76 => 20, 77 => 28, 78 => 16, 79 => 16, 80 => 8 }.fetch(family)
+        raise FormatError, "invalid native region payload" if payload.bytesize < fixed
+
+        fields = region_scalars(payload, family)
+        data = optional_region_data(payload, family, fixed)
+        count = data ? 32 + (data.fetch(:count_rects) * 16) + data.fetch(:trailing).bytesize : 0
+        wire_fixed = family == 80 ? 16 : fixed + 12
+        raise FormatError, "invalid native region span" if raw.bytesize < wire_fixed + count
+
+        fields[:cb_rgn_data] = count
+        fields[:body] = raw.byteslice((wire_fixed + count)..)
+        fields[:rgn_data] = data if data
+        [klass, fields]
+      end
+
+      def self.optional_region_data(payload, family, fixed)
+        present = family == 80 ? payload.byteslice(4, 4).unpack1("V") : 1
+        raise FormatError, "invalid native region presence" unless (0..1).cover?(present)
+        return region_data(payload.byteslice(fixed..)) if present == 1
+
+        raise FormatError, "invalid native clip reset" unless payload.bytesize == fixed
+
+        nil
+      end
+
+      def self.region_scalars(payload, family)
+        return { dw_mode: payload.unpack1("V") } if family == 80
+
+        fields = { rcl_bounds: %i[left top right bottom].zip(payload.unpack("l<4")).to_h }
+        fields[:ih_brush] = payload.byteslice(16, 4).unpack1("V") if [76, 77].include?(family)
+        fields[:szl_stroke] = %i[cx cy].zip(payload.byteslice(20, 8).unpack("l<2")).to_h if family == 77
+        fields
+      end
+
+      def self.region_data(payload)
+        raise FormatError, "invalid native region data" if payload.bytesize < 36
+
+        count, extra = payload.byteslice(20, 16).unpack("Q<2")
+        expected = 36 + (count * 16) + extra
+        raise FormatError, "invalid native region data length" unless payload.bytesize == expected
+
+        ResourceLimits::EmfRecords.check_count(count, record_bytes: 32 + (count * 16) + extra)
+
+        axes = %i[left top right bottom]
+        rectangles = payload.byteslice(36, count * 16).unpack("l<*").each_slice(4).map { |values| axes.zip(values).to_h }
+        { header_size: 32, region_type: payload.unpack1("V"), count_rects: count, rgn_size: count * 16,
+          bounds: axes.zip(payload.byteslice(4, 16).unpack("l<4")).to_h,
+          rectangles: rectangles, trailing: payload.byteslice(36 + (count * 16), extra) }
+      end
+
+      def self.call(payload, family)
+        return LegacyStateFields.call(payload, family) if [68, 73].include?(family)
+
+        klass, *layouts = LAYOUTS.fetch(family)
+        raise FormatError, "invalid native typed payload length" unless payload.bytesize == layouts.sum { |_, _, _, length| length }
+
+        offset = 0
+        fields = layouts.to_h do |field, axes, format, length|
+          values = payload.byteslice(offset, length).unpack(format)
+          offset += length
+          [field, axes ? axes.zip(values).to_h : values.first]
+        end
+        [klass, fields]
+      end
+    end
+  end
+end

data/lib/emf/native/font_fields.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "emf/emr/binary/font"
+
+module Emf
+  module Native
+    # Converts family 90 semantic fields directly into editable font objects.
+    class FontFields
+      LOG_FIELDS = %i[height width escapement orientation weight italic underline strike_out char_set
+                      out_precision clip_precision quality pitch_and_family].freeze
+      PANOSE_FIELDS = %i[family_type serif_style weight proportion contrast stroke_variation arm_style
+                         letterform midline x_height].freeze
+
+      def initialize(payload, raw)
+        @payload = payload
+        @raw = raw
+        @position = 0
+      end
+
+      def call
+        handle, kind, encoded_size = take(16).unpack("V2Q<")
+        font = case kind
+               when 0 then Emr::Binary::LogFont.new(log_font)
+               when 1 then panose
+               when 2 then extended
+               else raise FormatError, "invalid native font variant"
+               end
+        validate_length(kind, encoded_size)
+        wire = Emr::Binary::Records::CreateFontIndirectW.new(i_type: 82, n_size: @raw.bytesize, ih_object: handle)
+        wire.body.font = font
+        wire
+      end
+
+      private
+
+      def take(length)
+        raise FormatError, "invalid native font payload length" if length > @payload.bytesize - @position
+
+        value = @payload.byteslice(@position, length)
+        @position += length
+        value
+      end
+
+      def log_font
+        LOG_FIELDS.zip(take(28).unpack("l<5C8")).to_h.merge(facename: take(64).unpack("v32"))
+      end
+
+      def names
+        { log_font: log_font, fullname: take(128).unpack("v64"), style: take(64).unpack("v32") }
+      end
+
+      def panose
+        fields = names.merge(%i[version style_size match reserved].zip(take(16).unpack("V4")).to_h)
+        fields.merge!(vendor_id: take(4).bytes, culture: take(4).unpack1("V"),
+                      panose: PANOSE_FIELDS.zip(take(10).bytes).to_h, padding: take(2).bytes)
+        Emr::Binary::LogFontPanose.new(fields)
+      end
+
+      def extended
+        fields = names.merge(script: take(64).unpack("v32"))
+        signature, count = take(8).unpack("V2")
+        raise FormatError, "invalid native font design vector" unless signature == 0x08007664 && count <= 16
+
+        fields[:design_vector] = { signature: signature, num_axes: count, axis_values: take(count * 4).unpack("l<*") }
+        fields[:trailing] = @raw.byteslice((12 + @position - 16)..) || "".b
+        Emr::Binary::LogFontExDv.new(fields)
+      end
+
+      def validate_length(kind, encoded_size)
+        valid = valid_size?(kind, encoded_size)
+        raise FormatError, "invalid native font payload length" unless valid && @position == @payload.bytesize
+        return unless kind == 1
+
+        omitted = @payload.byteslice((16 + encoded_size)..)
+        raise FormatError, "invalid native partial font fields" unless omitted.bytes.all?(&:zero?)
+      end
+
+      def valid_size?(kind, encoded_size)
+        case kind
+        when 0 then encoded_size == 92 && @raw.bytesize == 104
+        when 1 then (93..320).cover?(encoded_size) && @raw.bytesize == encoded_size + 12
+        when 2 then encoded_size == @position - 16 && @raw.bytesize >= encoded_size + 12
+        end
+      end
+    end
+  end
+end

data/lib/emf/native/gradient_fields.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    module GradientFields
+      # The snapshot carries bounds, ulMode and the widened counts. Elements are
+      # not sized here: Ruby keeps everything after the fixed prefix as body.
+      def self.call(payload, raw)
+        raise FormatError, "invalid native gradient payload" if payload.bytesize < 36 || raw.bytesize < 36
+
+        mode, vertices, meshes = payload.byteslice(16, 20).unpack("VQ<2")
+        unless raw.byteslice(8, 16) == payload.byteslice(0, 16) && raw.byteslice(24, 8).unpack("V2") == [vertices, meshes] &&
+               raw.byteslice(32, 4).unpack1("V") == mode
+          raise FormatError, "invalid native gradient fields"
+        end
+
+        [Emr::Binary::Records::GradientFill,
+         { rcl_bounds: %i[left top right bottom].zip(payload.unpack("l<4")).to_h,
+           n_ver: vertices, n_tri: meshes, ul_mode: mode, body: raw.byteslice(36..) }]
+      end
+    end
+  end
+end

data/lib/emf/native/header.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    class Header
+      def signed(values)
+        values.pack("V*").unpack("l<*")
+      end
+
+      def rect(values)
+        Model::Geometry::Rect.new(**%i[left top right bottom].zip(signed(values)).to_h)
+      end
+
+      def size(values)
+        Model::Geometry::Size.new(**%i[cx cy].zip(signed(values)).to_h)
+      end
+
+      def call(fields, raw_header)
+        extension = if fields[22].anybits?(2)
+                      108
+                    else
+                      (fields[22].anybits?(1) ? 100 : 88)
+                    end
+        Model::Emr::Header.new(
+          n_size: fields[0], bounds: rect(fields[1, 4]), frame: rect(fields[5, 4]),
+          signature: fields[9], version: fields[10], n_bytes: fields[11], n_records: fields[12],
+          n_handles: fields[13], s_reserved: fields[14], n_description: fields[15], off_description: fields[16],
+          n_pal_entries: fields[17], device_pixels: size(fields[18, 2]), device_mm: size(fields[20, 2]),
+          cb_pixel_format: fields[23], off_pixel_format: fields[24], b_open_gl: fields[25],
+          szl_micrometers: size(fields[26, 2]), trailing: raw_header.byteslice(extension..) || "".b
+        )
+      end
+    end
+  end
+end