emf 0.1.2 → 0.2.0

data/lib/emf/emf_plus/stream.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Emf
+  module EmfPlus
+    # A lazy, typed view of the EMF+ records of a parsed Metafile. Reading never
+    # changes the Metafile; edits yield a new Metafile in which only the
+    # comments of edited segments are rebuilt. Framing problems are collected in
+    # #errors (never raised, never added to Metafile#errors) and the affected
+    # bytes stay in the segment, so nothing is dropped.
+    class Stream
+      include Enumerable
+
+      autoload :Segment, "emf/emf_plus/stream/segment"
+      autoload :RecordHandle, "emf/emf_plus/stream/record_handle"
+      autoload :EmfGap, "emf/emf_plus/stream/emf_gap"
+      autoload :Rebuild, "emf/emf_plus/stream/rebuild"
+      autoload :Editor, "emf/emf_plus/stream/editor"
+      autoload :LinkIndex, "emf/emf_plus/stream/link_index"
+      autoload :Conformance, "emf/emf_plus/stream/conformance"
+
+      attr_reader :source, :segments
+
+      def self.from_metafile(metafile)
+        errors = []
+        segments = metafile.records.each_with_index.filter_map do |record, index|
+          Segment.from_comment(index, record.wire, errors) if record.wire.is_a?(Emf::Emr::Binary::Records::Comment)
+        end
+        new(source: metafile, segments: segments, errors: errors, digests: digests_of(metafile, segments))
+      end
+
+      def self.digests_of(metafile, segments)
+        segments.map { |segment| Digest::SHA256.digest(metafile.records[segment.record_index].to_binary_s) }
+      end
+      private_class_method :digests_of
+
+      def initialize(source:, segments:, errors:, digests:)
+        @source = source
+        @segments = segments.freeze
+        @framing_errors = errors.freeze
+        @digests = digests.freeze
+      end
+
+      def ok? = errors.empty?
+
+      # Framing problems, then object table, effect link and conformance diagnostics.
+      def errors
+        @errors ||= (@framing_errors + objects.errors + links.errors + Conformance.check(records, segments)).freeze
+      end
+
+      # EMF+ records and EMF gaps in file order.
+      def entries
+        @entries ||= build_entries.freeze
+      end
+
+      def each(&block)
+        return to_enum(:each) unless block
+
+        entries.each(&block)
+      end
+
+      def each_record(&block)
+        return to_enum(:each_record) unless block
+
+        entries.each { |entry| yield entry unless entry.gap? }
+      end
+
+      def records = each_record.to_a
+
+      # True once a source comment's bytes differ from what this stream was built from.
+      def stale?
+        segments.each_with_index.any? do |segment, index|
+          Digest::SHA256.digest(source.records[segment.record_index].to_binary_s) != @digests[index]
+        end
+      end
+
+      def dirty? = segments.any?(&:dirty?)
+
+      # Returns a new Stream with `handle`'s record replaced; the receiver is unchanged.
+      def with_record(handle, new_record)
+        assert_fresh!
+        segment = segments.fetch(handle.segment_index)
+        position = segment.records.index { |record| record.equal?(handle.record) }
+        raise ArgumentError, "record does not belong to this stream" unless position
+
+        swapped = segments.dup.tap { |list| list[handle.segment_index] = segment.replace(position, new_record) }
+        self.class.new(source: source, segments: swapped, errors: @framing_errors, digests: @digests)
+      end
+
+      # Yields an Editor (#replace(handle, record)) and returns the edited Metafile.
+      def edit
+        editor = Editor.new(self)
+        yield editor
+        editor.stream.to_metafile
+      end
+
+      # The source itself when nothing was edited.
+      def to_metafile
+        assert_fresh!
+        return source unless dirty?
+
+        Rebuild.new(source, segments.select(&:dirty?)).call
+      end
+
+      def assert_fresh!
+        raise StaleStreamError, "the source metafile's EMF+ comments changed after this stream was built" if stale?
+      end
+
+      # The object table over this stream's records in stream order.
+      def objects
+        @objects ||= ObjectTable.new(records.map(&:record))
+      end
+
+      # Resolutions of the object references `handle`'s record carries.
+      def resolve(handle) = objects.resolve(handle.record, at: handle.stream_index)
+
+      def dc_spans = links.dc_spans
+
+      # The SerializableObject handle linked to an E-flag draw handle, or nil.
+      def effect_for(handle) = links.effect_for(handle)
+
+      private
+
+      def links
+        @links ||= LinkIndex.new(source, records, segments)
+      end
+
+      def build_entries
+        stream_index = 0
+        cursor = 0
+        segments.each_with_index.flat_map do |segment, segment_index|
+          gap = gap_before(cursor, segment.record_index)
+          cursor = segment.record_index + 1
+          offset = 0
+          comment_offset = source.records[segment.record_index].then { |record| record.offset if record.respond_to?(:offset) }
+          handles = segment.records.map do |record|
+            handle = RecordHandle.new(record: record, segment_index: segment_index, offset: offset, stream_index: stream_index,
+                                      comment_offset: comment_offset)
+            offset += record.to_binary.bytesize
+            stream_index += 1
+            handle
+          end
+          gap + handles
+        end + gap_before(cursor, source.records.size)
+      end
+
+      def gap_before(from, upto)
+        from < upto ? [EmfGap.new(from...upto)] : []
+      end
+    end
+  end
+end

data/lib/emf/emf_plus.rb

@@ -5,5 +5,14 @@ module Emf
     autoload :Parser, "emf/emf_plus/parser"
     autoload :Serializer, "emf/emf_plus/serializer"
     autoload :Binary, "emf/emf_plus/binary"
+    autoload :Frame, "emf/emf_plus/frame"
+    autoload :Records, "emf/emf_plus/records"
+    autoload :ObjectChain, "emf/emf_plus/object_chain"
+    autoload :ObjectTable, "emf/emf_plus/object_table"
+    autoload :Objects, "emf/emf_plus/objects"
+    autoload :Effects, "emf/emf_plus/effects"
+    autoload :Stream, "emf/emf_plus/stream"
+    autoload :StaleStreamError, "emf/error"
+    autoload :Links, "emf/emf_plus/links"
   end
 end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      # Read-only typed view of the DIB header (BITMAPCOREHEADER,
+      # BITMAPINFOHEADER, BITMAPV4HEADER, BITMAPV5HEADER) embedded in an EMR
+      # bitmap record, plus the bounds of its colour table. The record bytes
+      # are never touched; a malformed record yields a view with no header and
+      # a reason instead of raising.
+      class DibHeader < Struct.new(
+        :kind, :header_size, :width, :height, :planes, :bit_count, :compression, :size_image,
+        :x_pels_per_meter, :y_pels_per_meter, :clr_used, :clr_important,
+        :bitfield_mask_count, :color_table_offset, :color_table_entries, :color_table_bytes,
+        keyword_init: true
+      )
+        # header is nil whenever reason is set. The pixel array is judged
+        # separately so a header problem is never masked: bits_reason is nil
+        # when the header is unusable (the stride needs it) or the bits are
+        # sound, and valid? keeps meaning "the header is usable".
+        View = Struct.new(:header, :reason, :bits_offset, :bits_size, :bits_reason) do
+          def valid?
+            !header.nil?
+          end
+
+          def bits_valid?
+            valid? && bits_reason.nil?
+          end
+        end
+
+        KINDS = { 12 => :core, 40 => :info, 108 => :v4, 124 => :v5 }.freeze
+        BI_RGB = 0
+        BI_BITFIELDS = 3
+        BI_ALPHABITFIELDS = 6
+        BI_JPEG = 4
+        BI_PNG = 5
+        UNCOMPRESSED = [BI_RGB, BI_BITFIELDS, BI_ALPHABITFIELDS].freeze
+        private_constant :KINDS, :BI_RGB, :BI_BITFIELDS, :BI_ALPHABITFIELDS, :BI_JPEG, :BI_PNG, :UNCOMPRESSED
+
+        # offset/size are the record's offBmi/cbBmi (from record start);
+        # fixed is the byte length of the declared fixed part including the
+        # 8-byte EMR header; tail is the opaque remainder after it.
+        # bits_offset/bits_size are the record's offBits/cbBits.
+        def self.view(offset, size, fixed, tail, bits_offset: 0, bits_size: 0)
+          offset = offset.to_i
+          size = size.to_i
+          tail = tail.to_s
+          bits = [bits_offset.to_i, bits_size.to_i]
+          return View.new(nil, :absent, *bits) if size.zero?
+          return View.new(nil, :offset_in_fixed_part, *bits) if offset < fixed
+
+          start = offset - fixed
+          return View.new(nil, :past_record, *bits) if start + size > tail.bytesize
+
+          with_bits(build(tail.byteslice(start, size)), offset, size, fixed, tail.bytesize, bits)
+        end
+
+        def self.with_bits(view, offset, size, fixed, tail_size, bits)
+          view.bits_offset, view.bits_size = bits
+          view.bits_reason = bits_reason(view.header, offset, size, fixed, tail_size, bits) if view.valid?
+          view
+        end
+
+        def self.bits_reason(header, offset, size, fixed, tail_size, bits)
+          bits_offset, bits_size = bits
+          return :bits_absent if bits_size.zero?
+          return :bits_in_fixed_part if bits_offset < fixed
+          return :bits_past_record if bits_offset - fixed + bits_size > tail_size
+          return :bits_overlap_bmi if bits_offset < offset + size && offset < bits_offset + bits_size
+
+          :bits_smaller_than_image if bits_size < minimum_bits(header)
+        end
+
+        # Only uncompressed rows have a stride-derived minimum. RLE4/RLE8 runs
+        # can be far shorter than stride * height, and for BI_JPEG/BI_PNG
+        # (MS-WMF 2.2.2.3 BitmapInfoHeader) the pixel array is the encoded
+        # image, so bit_count does not describe it.
+        def self.minimum_bits(header)
+          return 0 unless UNCOMPRESSED.include?(header.compression)
+
+          (((header.width.abs * header.bit_count) + 31) / 32) * 4 * header.height.abs
+        end
+
+        def self.build(bmi)
+          return View.new(nil, :truncated) if bmi.bytesize < 4
+
+          header_size = bmi.unpack1("V")
+          kind = KINDS[header_size]
+          return View.new(nil, :unsupported_header_size) unless kind
+          return View.new(nil, :bmi_smaller_than_header) if bmi.bytesize < header_size
+
+          header = kind == :core ? core(bmi) : info(bmi, kind)
+          fits = header.color_table_offset + header.color_table_bytes <= bmi.bytesize
+          fits ? View.new(header, nil) : View.new(nil, :color_table_past_bmi)
+        end
+
+        def self.core(bmi)
+          width, height, planes, bit_count = bmi.unpack("x4v4")
+          make(:core, 12, width, height, planes, bit_count, 0, 0, 0, 0, 0, 0, 3)
+        end
+
+        def self.info(bmi, kind)
+          width, height, planes, bit_count, compression, size_image, xppm, yppm, clr_used, clr_important = bmi.unpack("x4l<2v2V2l<2V2")
+          make(kind, KINDS.key(kind), width, height, planes, bit_count, compression, size_image, xppm, yppm, clr_used, clr_important, 4)
+        end
+
+        def self.make(kind, header_size, width, height, planes, bit_count, compression, size_image, xppm, yppm, used, important, entry_size)
+          masks = mask_count(kind, compression)
+          entries = table_entries(kind, bit_count, compression, used)
+          new(kind: kind, header_size: header_size, width: width, height: height, planes: planes, bit_count: bit_count,
+              compression: compression, size_image: size_image, x_pels_per_meter: xppm, y_pels_per_meter: yppm,
+              clr_used: used, clr_important: important, bitfield_mask_count: masks,
+              color_table_offset: header_size + (masks * 4),
+              color_table_entries: entries, color_table_bytes: entries * entry_size)
+        end
+
+        # A BITMAPINFOHEADER with BI_BITFIELDS/BI_ALPHABITFIELDS stores the
+        # channel masks between the header and the colour table; V4/V5
+        # headers carry them inside the header itself.
+        def self.mask_count(kind, compression)
+          return 0 unless kind == :info
+
+          { BI_BITFIELDS => 3, BI_ALPHABITFIELDS => 4 }.fetch(compression, 0)
+        end
+
+        def self.table_entries(kind, bit_count, compression, used)
+          return 0 if kind == :info && compressed_image?(compression)
+          return used if bit_count > 8
+
+          used.zero? ? 1 << bit_count : used
+        end
+
+        def self.compressed_image?(compression)
+          [BI_JPEG, BI_PNG].include?(compression)
+        end
+
+        private_class_method :with_bits, :bits_reason, :minimum_bits, :compressed_image?, :build, :core, :info, :make,
+                             :mask_count, :table_entries
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Emf
+  module Emr
+    module Binary
+      # Reads the EMRTEXT string and Dx array of EMR_EXTTEXTOUTA/W from the
+      # record bytes. Offsets are from record start; a missing or out-of-range
+      # part is nil, never an error.
+      module ExtTextOutFields
+        ETO_NO_RECT = 0x100
+        ETO_PDY = 0x2000
+
+        # Raw string bytes (nChars * #char_size at offString), or nil.
+        def string_bytes
+          slice_of_record(off_string, n_chars * char_size)
+        end
+
+        # The string as UTF-8, or nil. See the A/W classes for the decoding.
+        def text
+          bytes = string_bytes
+          bytes && decode_text(bytes)
+        end
+
+        # Dx array: unsigned 32-bit values at offDx, nChars of them (2 * nChars
+        # with ETO_PDY), or nil when offDx is 0 or the range leaves the record.
+        def dx
+          count = n_chars * (f_options.anybits?(ETO_PDY) ? 2 : 1)
+          bytes = slice_of_record(off_dx, count * 4)
+          bytes&.unpack("V*")
+        end
+
+        private
+
+        def slice_of_record(offset, length)
+          return unless offset.positive? && length.positive?
+
+          bytes = to_binary_s
+          bytes.byteslice(offset, length) if offset + length <= bytes.bytesize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module Emr
+    module Binary
+      class ExtendedPenBuffers < BinData::Record
+        mandatory_parameters :fixed_size, :first_offset, :first_length, :second_offset, :second_length
+        string :first_padding, read_length: -> { [eval_parameter(:first_offset) - eval_parameter(:fixed_size), 0].max }
+        string :first_bitmap, read_length: :first_length
+        string :second_padding, read_length: lambda {
+          finish = [eval_parameter(:first_offset), eval_parameter(:fixed_size)].max + eval_parameter(:first_length)
+          [eval_parameter(:second_offset) - finish, 0].max
+        }
+        string :second_bitmap, read_length: :second_length
+        rest :trailing
+      end
+    end
+  end
+end
+
+BinData::RegisteredClasses.register("extended_pen_buffers", Emf::Emr::Binary::ExtendedPenBuffers)