emf 0.1.2 → 0.2.0

data/lib/emf/native/small_text_fields.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Hydrates the fixed EMRSMALLTEXTOUT prefix and leaves option-dependent
+    # text bytes opaque for the Ruby visitor.
+    module SmallTextFields
+      FIXED_SIZE = 36
+
+      def self.call(raw)
+        return [Emr::Binary::Records::Raw, { payload: raw.byteslice(8..) }] if raw.bytesize < FIXED_SIZE
+
+        [Emr::Binary::Records::SmallTextOut,
+         {
+           x_dest: raw.byteslice(8, 4).unpack1("l<"),
+           y_dest: raw.byteslice(12, 4).unpack1("l<"),
+           c_chars: raw.byteslice(16, 4).unpack1("V"),
+           fu_options: raw.byteslice(20, 4).unpack1("V"),
+           i_graphics_mode: raw.byteslice(24, 4).unpack1("V"),
+           ex_scale: raw.byteslice(28, 4).unpack1("e"),
+           ey_scale: raw.byteslice(32, 4).unpack1("e"),
+           body: raw.byteslice(FIXED_SIZE..)
+         }]
+      end
+    end
+  end
+end

data/lib/emf/native/snapshot.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # Decodes the versioned transport, never the original EMF wire format.
+    class Snapshot
+      # Five integers per record, in record order: index, offset, length,
+      # type | family << 32 and payload length (the 40-byte entry as u64 words).
+      attr_reader :header, :raw_header, :table, :record_count, :diagnostics, :trailing, :unframed
+
+      TYPE_MASK = 0xFFFF_FFFF
+
+      def initialize(bytes)
+        @bytes = bytes
+        @position = 0
+        raise FormatError, "invalid native snapshot schema" unless take(4) == "EMFS"
+
+        schema = u32
+        raise FormatError, "invalid native snapshot schema" unless [2, 3].include?(schema)
+        raise FormatError, "invalid native snapshot length" unless u64 == bytes.bytesize
+
+        header_length, record_count, diagnostic_count, trailing_length, unframed_length = Array.new(5) { u64 }
+        raise FormatError, "invalid native snapshot counts" if record_count > bytes.bytesize / 40 || diagnostic_count > bytes.bytesize / 40
+
+        @header = Array.new(28) { u32 }
+        @raw_header = take(header_length)
+        @record_count = record_count
+        schema == 3 ? read_table : read_entries
+        @diagnostics = Array.new(diagnostic_count) { take(40).unpack("V4Q<3") }
+        @trailing = take(trailing_length)
+        @unframed = take(unframed_length)
+        raise FormatError, "unconsumed native snapshot bytes" unless @position == bytes.bytesize
+      end
+
+      def take(length)
+        raise FormatError, "truncated native snapshot" if length > @bytes.bytesize - @position
+
+        result = @bytes.byteslice(@position, length)
+        @position += length
+        result
+      end
+
+      def u32
+        take(4).unpack1("V")
+      end
+
+      def u64
+        take(8).unpack1("Q<")
+      end
+
+      # The record at `index` as a Hash with its typed payload.
+      def record(index)
+        base = index * 5
+        type_family = @table[base + 3]
+        { index: @table[base], offset: @table[base + 1], length: @table[base + 2], type: type_family & TYPE_MASK,
+          family: type_family >> 32, payload: payload(index) }
+      end
+
+      def records
+        @records ||= Array.new(@record_count) { |index| record(index) }
+      end
+
+      def payload(index)
+        length = @table[(index * 5) + 4]
+        length.zero? ? EMPTY_PAYLOAD : @bytes.byteslice(@payload_at[index], length)
+      end
+
+      private
+
+      EMPTY_PAYLOAD = "".b.freeze
+      private_constant :EMPTY_PAYLOAD
+
+      # Schema 3: every entry in one fixed-stride table, then the payloads.
+      def read_table
+        raise FormatError, "truncated native snapshot" if @bytes.bytesize - @position < @record_count * 40
+
+        @table = @bytes.unpack("Q<#{@record_count * 5}", offset: @position)
+        @position += @record_count * 40
+        @payload_at = Array.new(@record_count) do |index|
+          at = @position
+          @position += @table[(index * 5) + 4]
+          at
+        end
+        raise FormatError, "truncated native snapshot" if @position > @bytes.bytesize
+      end
+
+      # Schema 2: each entry is followed by its payload.
+      def read_entries
+        @table = []
+        @payload_at = Array.new(@record_count) do
+          raise FormatError, "truncated native snapshot" if @bytes.bytesize - @position < 40
+
+          @table.concat(@bytes.unpack("Q<5", offset: @position))
+          @position += 40
+          at = @position
+          take(@table.last)
+          at
+        end
+      end
+    end
+  end
+end

data/lib/emf/native/wmf_bitmap_fields.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    class WmfBitmapFields
+      def initialize(record, raw)
+        @record = record
+        @raw = raw
+        @type = record.fetch(:type)
+        @offset = record.fetch(:offset)
+        @payload = record.fetch(:payload)
+      end
+
+      def call
+        validate(@record.fetch(:family) == 11 && @raw.bytesize >= 6 && @raw.bytesize.even? &&
+                 @payload.bytesize <= Wmf::Binary::MAX_INPUT_BYTES)
+        validate(@raw.unpack("Vv") == [@raw.bytesize / 2, @type])
+        kind = @type & 0xFF
+        fields = decode_fields(kind)
+        body = Wmf::BitmapCodec.encode_fields(fields, @type)
+        validate(@raw.bytesize == body.bytesize + 6 && @raw.byteslice(6..) == body)
+        Wmf::BitmapCodec::RECORDS.fetch(kind).new(**fields, type_id: @type, offset: @offset)
+      rescue SerializeError
+        validate(false)
+      end
+
+      private
+
+      def decode_fields(kind)
+        names = Wmf::BitmapCodec::FIELDS.fetch(kind)
+        fixed = names.length * 4
+        validate(@payload.bytesize >= fixed + 8)
+        values = names.each_with_index.map do |field, index|
+          format = Wmf::BitmapCodec.field_type(kind, field) == :int16 ? "l<" : "V"
+          @payload.byteslice(index * 4, 4).unpack1(format)
+        end
+        names.zip(values).to_h.merge(image_fields(kind, fixed))
+      end
+
+      def image_fields(kind, fixed)
+        presence, length = @payload.byteslice(fixed, 8).unpack("V2")
+        validate([0, 1].include?(presence) && @payload.bytesize == fixed + 8 + length)
+        absent = presence.zero?
+        validate(absent ? Wmf::BitmapCodec.optional?(kind) && length.zero? : length.positive? && length.even?)
+        prefix = Wmf::BitmapCodec.wire_fields(kind, absent).sum { |field| field == :raster_operation ? 4 : 2 }
+        validate(@raw.bytesize >= 6 + prefix)
+        { bitmap: absent ? nil : @payload.byteslice(fixed + 8, length),
+          suffix: absent ? @raw.byteslice((6 + prefix)..) : "".b }
+      end
+
+      def validate(condition)
+        return if condition
+
+        raise ParseError.new(offset: @offset, record_code: @type, message: "invalid native WMF bitmap record at offset #{@offset}")
+      end
+    end
+  end
+end

data/lib/emf/native/wmf_brush_fields.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    class WmfBrushFields
+      def initialize(record, raw)
+        @record = record
+        @raw = raw
+        @type = record.fetch(:type)
+        @offset = record.fetch(:offset)
+        @payload = record.fetch(:payload)
+      end
+
+      def call
+        validate(@record.fetch(:family) == 10 && @raw.bytesize >= 6 && @raw.bytesize.even? &&
+                 @payload.bytesize <= Wmf::Binary::MAX_INPUT_BYTES)
+        fields = @type & 0xFF == 0xF9 ? pattern : dib
+        record = Wmf::BrushCodec::RECORDS.fetch(@type & 0xFF).new(**fields, type_id: @type, offset: @offset)
+        prefix = Wmf::BrushCodec.encode_payload(record)
+        validate(@raw.bytesize >= prefix.bytesize + 6 && @raw.byteslice(6, prefix.bytesize) == prefix)
+        if record.is_a?(Model::Wmf::Records::CreatePatternBrush)
+          record.suffix = @raw.byteslice((6 + prefix.bytesize)..)
+        else
+          validate(@raw.bytesize == prefix.bytesize + 6)
+        end
+        record
+      rescue SerializeError
+        validate(false)
+      end
+
+      private
+
+      def pattern
+        validate(@payload.bytesize >= 50)
+        signed = @payload.unpack("l<4")
+        planes, bits_pixel = @payload.byteslice(16, 8).unpack("V2")
+        length = @payload.byteslice(46, 4).unpack1("V")
+        validate(signed.all? { |value| value.between?(-0x8000, 0x7FFF) } && planes <= 0xFF && bits_pixel <= 0xFF)
+        expected = Wmf::BrushCodec.pattern_length(signed[1], signed[2], planes, bits_pixel)
+        validate(expected && expected == length && @payload.bytesize == 50 + length && @raw.bytesize >= 38 + length)
+        Wmf::BrushCodec::SIGNED_FIELDS.zip(signed).to_h.merge(
+          planes: planes, bits_pixel: bits_pixel, bits: @payload.byteslice(24, 4), reserved: @payload.byteslice(28, 18),
+          pattern: @payload.byteslice(50, length)
+        )
+      end
+
+      def dib
+        validate(@payload.bytesize >= 14)
+        style, usage, length = @payload.unpack("V3")
+        validate(style <= 0xFFFF && usage <= 0xFFFF && (style == 3 || usage <= 2) && length.positive? && length.even? &&
+                 @payload.bytesize == 12 + length && @raw.bytesize == 10 + length)
+        { style: style, color_usage: usage, target: @payload.byteslice(12, length) }
+      end
+
+      def validate(condition)
+        return if condition
+
+        raise ParseError.new(offset: @offset, record_code: @type, message: "invalid native WMF brush record at offset #{@offset}")
+      end
+    end
+  end
+end

data/lib/emf/native/wmf_fields.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "wmf_text_fields"
+require_relative "wmf_palette_fields"
+require_relative "wmf_region_fields"
+require_relative "wmf_brush_fields"
+require_relative "wmf_bitmap_fields"
+require_relative "wmf_remaining_fields"
+
+module Emf
+  module Native
+    class WmfFields
+      def initialize(record, raw)
+        @record = record
+        @raw = raw
+        @type = record.fetch(:type)
+        @offset = record.fetch(:offset)
+        @payload = record.fetch(:payload)
+        @function = @type & 0xFF
+      end
+
+      def call
+        if @type.zero?
+          validate(@record.fetch(:family) == 1 && @payload.empty? && @raw.bytesize == 6)
+          return Model::Wmf::Records::Eof.new(offset: @offset)
+        end
+        return prefix_record if Wmf::Binary::PREFIX_FUNCTIONS.include?(@function)
+        return fixed(Wmf::Binary::OBJECT_RECORDS.fetch(@function), 4) if Wmf::Binary::OBJECT_RECORDS.key?(@function)
+        return WmfTextFields.new(@record, @raw).call if Wmf::Binary::TEXT_FUNCTIONS.include?(@function)
+        return points(Wmf::Binary::POINT_ARRAY_RECORDS.fetch(@function)) if Wmf::Binary::POINT_ARRAY_RECORDS.key?(@function)
+        return fixed(Wmf::Binary::FIXED_RECORDS.fetch(@function), 2) if Wmf::Binary::FIXED_RECORDS.key?(@function)
+
+        Model::Wmf::Records::UnknownRecord.new(type_id: @type, raw_bytes: @raw, offset: @offset)
+      end
+
+      private
+
+      def prefix_record
+        if Wmf::GeometryCodec::RECORDS.key?(@function) || Wmf::DcEscapeCodec::RECORDS.key?(@function)
+          return WmfRemainingFields.new(@record, @raw).call
+        end
+        return WmfBitmapFields.new(@record, @raw).call if Wmf::BitmapCodec::RECORDS.key?(@function)
+
+        return WmfBrushFields.new(@record, @raw).call if Wmf::BrushCodec::RECORDS.key?(@function)
+        return font if @function == 0xFB
+        return state(Wmf::Binary::STATE_RECORDS.fetch(@function)) if Wmf::Binary::STATE_RECORDS.key?(@function)
+
+        if Wmf::RegionCodec::RECORDS.key?(@function)
+          WmfRegionFields.new(@record, @raw).call
+        else
+          WmfPaletteFields.new(@record, @raw).call
+        end
+      end
+
+      def font
+        klass = Model::Wmf::Records::CreateFontIndirect
+        prefix_size = 6 + klass::PAYLOAD_BYTES
+        validate(@record.fetch(:family) == 7 && @payload.bytesize == 84 &&
+                 @raw.bytesize >= prefix_size && @raw.bytesize.even?)
+        signed = @payload.byteslice(0, 20).unpack("l<5")
+        bytes = @payload.byteslice(20, 32).unpack("V8")
+        validate(signed.all? { |value| value.between?(-0x8000, 0x7FFF) } && bytes.all? { |value| value <= 0xFF })
+        values = signed + bytes + [@payload.byteslice(52, 32)]
+        fields = klass::WIRE_FIELDS.zip(values).to_h
+        klass.new(**fields, type_id: @type, offset: @offset, suffix: @raw.byteslice(prefix_size..))
+      end
+
+      def state(klass)
+        fields = klass::WIRE_FIELDS
+        prefix_size = 6 + klass::PAYLOAD_BYTES
+        validate(@record.fetch(:family) == 6 && @payload.bytesize == fields.length * 4 &&
+                 @raw.bytesize >= prefix_size && @raw.bytesize.even?)
+        values = @payload.unpack("V*")
+        values.zip(klass::WIRE_TYPES).each do |value, type|
+          validate(type != :uint16 || value <= 0xFFFF)
+        end
+        klass.new(**fields.zip(values).to_h, type_id: @type, offset: @offset, suffix: @raw.byteslice(prefix_size..))
+      end
+
+      def fixed(klass, family)
+        fields = klass::WIRE_FIELDS
+        wire_size = family == 4 ? klass::PAYLOAD_BYTES : fields.length * 2
+        validate(@record.fetch(:family) == family && @payload.bytesize == fields.length * 4 && @raw.bytesize == wire_size + 6)
+        values = @payload.unpack(family == 4 ? "V*" : "l<*")
+        if family == 4
+          values = values.zip(klass::WIRE_TYPES).map { |value, type| type == :int16 && value >= 0x80000000 ? value - 0x100000000 : value }
+        end
+        klass.new(**fields.zip(values).to_h, type_id: @type, offset: @offset)
+      end
+
+      def points(klass)
+        validate(@record.fetch(:family) == 3 && @payload.bytesize >= 16)
+        count, polygons = @payload.unpack("Q<2")
+        validate(@payload.bytesize == 16 + (polygons * 4) + (count * 8))
+        counts = @payload.byteslice(16, polygons * 4).unpack("V*")
+        multi = klass == Model::Wmf::Records::PolyPolygon
+        if multi
+          validate(@raw.bytesize == 8 + (polygons * 2) + (count * 4) && counts.sum == count)
+        else
+          minimum = klass == Model::Wmf::Records::Polygon ? 2 : 0
+          validate(polygons.zero? && count.between?(minimum, 0x7FFF) && @raw.bytesize == 8 + (count * 4))
+        end
+        coordinates = @payload.byteslice((16 + (polygons * 4))..).unpack("l<*")
+        points = coordinates.each_slice(2).map { |x, y| Model::Wmf::Records::PointS.new(x: x, y: y) }
+        fields = { points: points, type_id: @type, offset: @offset }
+        fields[:points_per_polygon] = counts if multi
+        klass.new(**fields)
+      end
+
+      def validate(condition)
+        return if condition
+
+        raise ParseError.new(offset: @offset, record_code: @type, message: "invalid native WMF typed record at offset #{@offset}")
+      end
+    end
+  end
+end

data/lib/emf/native/wmf_hydrator.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative "wmf_fields"
+require_relative "wmf_snapshot"
+require_relative "wmf_rejection"
+
+module Emf
+  module Native
+    class WmfHydrator
+      # Native parsing is authoritative for accepted input. A rejection, from the core or the hydrator, is reported
+      # with the native first-rejection detail mapped to the contract's error; when the contract would accept the
+      # input the native rejection is raised as is.
+      def self.parse(loader, input)
+        loader.wmf_document(input) do |document|
+          new(WmfSnapshot.new(loader.wmf_snapshot(document)), input).call
+        end
+      rescue Emf::Error => e
+        found = WmfRejection.read(loader.wmf_rejection(input, Wmf::Binary::MAX_INPUT_BYTES, Wmf::Binary::MAX_RECORDS))
+        raise WmfRejection.error(found, input) if found
+
+        raise e
+      end
+
+      def initialize(snapshot, input)
+        @snapshot = snapshot
+        @input = input
+      end
+
+      def call
+        @errors = []
+        header = hydrate_header
+        records = hydrate_records
+        recovered = Wmf::Evidence.reference_recovery(@input, @errors)
+        Wmf::Binary.validate_objects(records, header.number_of_objects, recovered: recovered) do |record, message|
+          fail_record(record.offset, record.type_id, message)
+        end
+        Model::Metafile.new(format: :wmf, header: header, records: records,
+                            errors: Wmf::Evidence.ordered(@errors + Wmf::Evidence.drift_errors(@input)),
+                            trailing: @input.byteslice(@limit..).to_s)
+      end
+
+      private
+
+      def hydrate_header
+        type, size, version, words, objects, maximum, members, placeable, eof, reserved = @snapshot.header
+        validate_header(type, size, version, placeable, eof, reserved)
+        @start = placeable == 1 ? 22 : 0
+        # The record stream ends after the first EOF record, whatever its length or the declared Size (both are
+        # recovered); the core keeps reading past an EOF it does not accept as final, so the stream is cut here.
+        @records = framed_records
+
+        placeable_header = hydrate_placeable(type) if placeable == 1
+        raise_framing_error if @records.empty?
+        @limit = @records.last.fetch(:offset) + @records.last.fetch(:length)
+
+        Model::Wmf::Header.new(type: type, version: version, size_words: words, number_of_objects: objects,
+                               max_record_words: maximum, number_of_members: members, placeable: placeable_header)
+      end
+
+      def validate_header(type, size, version, placeable, eof, reserved)
+        valid = [1, 2].include?(type) && size == 9 && [0x100, 0x300].include?(version) &&
+                [0, 1].include?(placeable) && [0, 1].include?(eof) && reserved.zero?
+        raise FormatError, "invalid native WMF header" unless valid
+        raise FormatError, "invalid native WMF source length" unless @snapshot.source_length == @input.bytesize
+        raise FormatError, "WMF input too large" if @input.bytesize > Wmf::Binary::MAX_INPUT_BYTES
+      end
+
+      # The snapshot's records up to and including the first EOF record; empty when the core found none.
+      def framed_records
+        index = @snapshot.records.index { |record| record.fetch(:type).zero? }
+        index ? @snapshot.records.first(index + 1) : []
+      end
+
+      # Core diagnostics 6-10 are record framing failures; Ruby raises ParseError for them.
+      FRAMING_DIAGNOSTICS = {
+        6 => "invalid record length", 7 => "truncated record", 8 => "invalid EOF record",
+        9 => "missing EOF record", 10 => "malformed record payload"
+      }.freeze
+      private_constant :FRAMING_DIAGNOSTICS
+
+      def raise_framing_error
+        kind, has_function, function, _detail, offset = @snapshot.diagnostics.find { |entry| FRAMING_DIAGNOSTICS.key?(entry.first) }
+        raise FormatError, "invalid native WMF header" unless kind
+
+        raise ParseError.new(offset: offset, record_code: has_function == 1 ? function : nil,
+                             message: "WMF #{FRAMING_DIAGNOSTICS.fetch(kind)} at offset #{offset}")
+      end
+
+      def hydrate_placeable(type)
+        handle, left, top, right, bottom, inch, reserved, checksum = @snapshot.placeable
+        raise FormatError, "invalid native WMF placeable header" unless reserved.zero? && (type != 2 || handle.zero?)
+
+        @errors << Wmf::Evidence.recovered_error(203, @input, nil) unless checksum == Wmf::Binary.checksum(@input.byteslice(0, 20))
+
+        Model::Wmf::PlaceableHeader.new(handle: handle, left: left, top: top, right: right, bottom: bottom,
+                                        inch: inch, checksum: checksum)
+      end
+
+      def hydrate_records
+        if @records.length > Wmf::Binary::MAX_RECORDS
+          raise ResourceLimitError.new(resource: :record_count, limit: Wmf::Binary::MAX_RECORDS,
+                                       actual: Wmf::Binary::MAX_RECORDS + 1)
+        end
+
+        position = @start + 18
+        records = @records.each_with_index.map do |record, index|
+          length = record.fetch(:length)
+          offset = record.fetch(:offset)
+          validate_span(record, index, position)
+          position += length
+          hydrate_record(record, @input.byteslice(offset, length)).declare_size(length / 2)
+        end
+        unless position == @limit && records.last.is_a?(Model::Wmf::Records::Eof) && records.one?(Model::Wmf::Records::Eof)
+          raise FormatError, "WMF requires one final EOF record"
+        end
+
+        records
+      end
+
+      # A recoverable shape is decoded by the Ruby contract itself (Wmf::Recovery) on the record's own bytes, so both
+      # backends build the same record and error; every other record comes from the native typed fields.
+      def hydrate_record(record, raw)
+        recovered, reason = Wmf::Recovery.record(raw, record.fetch(:type), record.fetch(:offset))
+        return WmfFields.new(record, raw).call unless reason
+
+        @errors << Wmf::Evidence.recovered_error(reason, @input, record.fetch(:offset), record.fetch(:type))
+        recovered
+      end
+
+      def validate_span(record, index, position)
+        length = record.fetch(:length)
+        offset = record.fetch(:offset)
+        return if record.fetch(:index) == index && offset == position && length >= 6 && length.even? && length <= @limit - offset
+
+        raise FormatError, "invalid native WMF record span"
+      end
+
+      def fail_record(offset, type, message)
+        raise ParseError.new(offset: offset, record_code: type, message: "WMF #{message} at offset #{offset}")
+      end
+    end
+  end
+end

data/lib/emf/native/wmf_loading.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    # The WMF entry points of the native library, loaded on first use. Mixed into Loader, which owns the
+    # buffer, status and pointer helpers these call.
+    module WmfLoading
+      def wmf_document(bytes)
+        load_wmf_functions
+        output = slot
+        checked(:emf_wmf_parse, bytes, bytes.bytesize, 0, output)
+        yield pointer(output)
+      ensure
+        invoke(:emf_wmf_document_free, pointer(output)) if output && pointer(output) != 0
+      end
+
+      def wmf_snapshot(document)
+        buffer(:emf_wmf_document_snapshot, document)
+      end
+
+      # The first phase of the Ruby WMF contract that rejects `bytes`, under the caller's limits (WMFR v1).
+      def wmf_rejection(bytes, max_input_bytes, max_records)
+        load_wmf_functions
+        buffer(:emf_wmf_rejection, bytes, bytes.bytesize, max_input_bytes, max_records)
+      end
+
+      private
+
+      def load_wmf_functions
+        return if @functions.key?(:emf_wmf_parse)
+
+        pointer = Loader::POINTER
+        uint64 = Loader::UINT64
+        signatures = {
+          emf_wmf_parse: [[pointer, uint64, pointer, pointer, pointer], Fiddle::TYPE_INT],
+          emf_wmf_document_snapshot: [[pointer, pointer, pointer], Fiddle::TYPE_INT],
+          emf_wmf_rejection: [[pointer, uint64, uint64, uint64, pointer, pointer], Fiddle::TYPE_INT],
+          emf_wmf_document_free: [[pointer], Fiddle::TYPE_VOID]
+        }
+        functions = signatures.to_h do |name, (arguments, result)|
+          [name, Fiddle::Function.new(@library[name.to_s], arguments, result)]
+        end
+        @functions.merge!(functions)
+      rescue Fiddle::DLError => e
+        raise Unavailable, "native WMF backend could not load: #{e.message}"
+      end
+    end
+  end
+end

data/lib/emf/native/wmf_palette_fields.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Emf
+  module Native
+    class WmfPaletteFields
+      def initialize(record, raw)
+        @record = record
+        @raw = raw
+        @type = record.fetch(:type)
+        @offset = record.fetch(:offset)
+        @payload = record.fetch(:payload)
+      end
+
+      def call
+        klass = Wmf::PaletteCodec::RECORDS.fetch(@type & 0xFF)
+        validate(@record.fetch(:family) == 8 && @raw.bytesize.even?)
+        fields, prefix = if klass <= Model::Wmf::Records::PaletteRecord
+                           entries
+                         elsif klass == Model::Wmf::Records::RealizePalette
+                           validate(@payload.empty?)
+                           [{}, 6]
+                         else
+                           scalar(klass)
+                         end
+        validate(@raw.bytesize >= prefix)
+        klass.new(**fields, type_id: @type, offset: @offset, suffix: @raw.byteslice(prefix..))
+      end
+
+      private
+
+      def entries
+        validate(@payload.bytesize >= 8)
+        start, count = @payload.unpack("V2")
+        validate(start <= 0xFFFF && count <= 0xFFFF && @payload.bytesize == 8 + (count * 16))
+        prefix = 10 + (count * 4)
+        validate(@raw.bytesize >= prefix)
+        values = @payload.byteslice(8..).unpack("V*")
+        validate(values.all? { |value| value <= 0xFF })
+        palette = values.each_slice(4).map do |entry|
+          Model::Wmf::Records::PaletteEntry.new(**Wmf::PaletteCodec::ENTRY_FIELDS.zip(entry).to_h)
+        end
+        [{ start: start, entries: palette }, prefix]
+      end
+
+      def scalar(klass)
+        validate(@payload.bytesize == 4)
+        value = @payload.unpack1("V")
+        validate(value <= 0xFFFF)
+        field = klass == Model::Wmf::Records::SelectPalette ? :object_index : :entry_count
+        [{ field => value }, 8]
+      end
+
+      def validate(condition)
+        return if condition
+
+        raise ParseError.new(offset: @offset, record_code: @type, message: "invalid native WMF palette record at offset #{@offset}")
+      end
+    end
+  end
+end