emf 0.1.2 → 0.2.0

data/lib/emf/emf_plus/records/primitives/blend_factors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/binary/float32_le"
+require "emf/emf_plus/records/primitives/bounded_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusBlendFactors (2.2.2.5).
+        class BlendFactors < Body
+          endian :little
+          uint32 :position_count
+          bounded_array :blend_positions, type: :float32_le, element_size: 4, initial_length: :position_count
+          bounded_array :blend_factors, type: :float32_le, element_size: 4, initial_length: :position_count
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/bounded_array.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # A BinData array whose untrusted `initial_length` is checked against
+        # the bytes left in the stream before any element is built. Each
+        # element takes at least `element_size` bytes, so a count that cannot
+        # fit raises EOFError (an IOError, the signal a short read already
+        # gives) instead of allocating count elements.
+        class BoundedArray < BinData::Array
+          # Extended onto each instance after the initial-length plugin, so
+          # its do_read runs first.
+          module Guard
+            def do_read(io)
+              count = eval_parameter(:initial_length)
+              needed = count * eval_parameter(:element_size)
+              left = io.num_bytes_remaining
+              raise EOFError, "#{count} elements need at least #{needed} bytes, #{left} left" if needed > left
+
+              super
+            end
+          end
+
+          mandatory_parameter :element_size
+
+          def initialize_shared_instance
+            super
+            extend Guard
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/byte_reader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # Reads exact byte counts from a StringIO for the hand-parsed
+        # structures; a short read raises EOFError (an IOError), the same
+        # signal BinData gives, so callers map it to ParseError once.
+        module ByteReader
+          private
+
+          def take(io, count, what)
+            bytes = io.read(count)
+            return bytes if bytes && bytes.bytesize == count
+
+            raise EOFError, "#{what} needs #{count} bytes, #{io.size - io.pos} left"
+          end
+
+          def remaining(io) = io.size - io.pos
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/character_range.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusCharacterRange (2.2.2.8).
+        # BinData reserves `first` and `length`, so the spec names First and
+        # Length are first_position and range_length here.
+        class CharacterRange < Body
+          endian :little
+          int32 :first_position
+          int32 :range_length
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/compressed_image.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusCompressedImage (2.2.2.10).
+        class CompressedImage < Body
+          endian :little
+          rest :compressed_image_data
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/focus_scale_data.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusFocusScaleData (2.2.2.18).
+        class FocusScaleData < Body
+          endian :little
+          uint32 :focus_scale_count
+          float32_le :focus_scale_x
+          float32_le :focus_scale_y
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/graphics_version.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusGraphicsVersion (2.2.2.19): 20-bit MetafileSignature (0xDBC01)
+        # above a 12-bit GraphicsVersion in one little-endian dword.
+        class GraphicsVersion < Body
+          endian :little
+          uint32 :raw
+
+          def metafile_signature = raw >> 12
+          def graphics_version = raw & 0xFFF
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/language_identifier.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusLanguageIdentifier (2.2.2.23): 6-bit SubLanguageId above a
+        # 10-bit PrimaryLanguageId. The containing objects reserve a full
+        # dword for it, so the whole dword is kept.
+        class LanguageIdentifier < Body
+          endian :little
+          uint32 :raw
+
+          def primary_language_id = raw & 0x3FF
+          def sub_language_id = (raw >> 10) & 0x3F
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/metafile.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusMetafile (2.2.2.27).
+        class Metafile < Body
+          endian :little
+          uint32 :metafile_type
+          uint32 :metafile_data_size
+          string :metafile_data, read_length: :metafile_data_size
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/palette.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emf_plus/records/primitives/bounded_array"
+require "emf/emf_plus/records/primitives/argb"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPalette (2.2.2.28).
+        class Palette < Body
+          endian :little
+          uint32 :palette_style_flags
+          uint32 :palette_count
+          bounded_array :palette_entries, type: :argb, element_size: 4, initial_length: :palette_count
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/path.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "emf/emf_plus/records/primitives/byte_reader"
+require "emf/emf_plus/records/primitives/graphics_version"
+require "emf/emf_plus/records/primitives/path_point_type"
+require "emf/emf_plus/records/primitives/path_point_type_rle"
+require "emf/emf_plus/records/primitives/point_array"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPath (2.2.1.6) without its AlignmentPadding, which the caller
+        # keeps. Same surface as a BinData record (`read`, `num_bytes`,
+        # `to_binary_s`); hand-parsed because the point and type encodings are
+        # chosen by the flags and the RLE run list has no stored length.
+        class Path
+          include ByteReader
+
+          RELATIVE_FLAG = 0x0800
+          COMPRESSED_FLAG = 0x4000
+          HEADER_SIZE = 12
+          MIN_POINT_SIZE = { relative: 2, compressed: 4, float: 8 }.freeze
+          private_constant :MIN_POINT_SIZE
+
+          attr_reader :version, :point_count, :flags, :points, :point_types
+
+          def read(source)
+            io = StringIO.new(source)
+            @version = GraphicsVersion.new.read(io)
+            @point_count, @flags = take(io, 8, "PathPointCount and PathPointFlags").unpack("VV")
+            require_room(io)
+            @points = PointArray.new(point_count: point_count, relative: relative?, compressed: compressed?).read(io)
+            @point_types = relative? ? read_runs(io) : read_types(io)
+            @size = io.pos
+            self
+          end
+
+          def relative? = flags.anybits?(RELATIVE_FLAG)
+          # The C flag is undefined, and ignored, when R is set.
+          def compressed? = !relative? && flags.anybits?(COMPRESSED_FLAG)
+          def num_bytes = @size
+
+          def to_binary_s
+            version.to_binary_s + [point_count, flags].pack("VV") + points.to_binary_s +
+              point_types.map(&:to_binary_s).join
+          end
+
+          private
+
+          def point_kind
+            if relative? then :relative
+            elsif compressed? then :compressed
+            else :float
+            end
+          end
+
+          def require_room(io)
+            needed = (point_count * MIN_POINT_SIZE.fetch(point_kind)) + min_type_bytes
+            return if needed <= remaining(io)
+
+            raise EOFError, "#{point_count} path points need at least #{needed} bytes, #{remaining(io)} left"
+          end
+
+          def min_type_bytes
+            return point_count unless relative?
+
+            point_count.zero? ? 0 : PathPointTypeRLE.new.num_bytes
+          end
+
+          def read_types(io)
+            Array.new(point_count) { PathPointType.new.read(io) }
+          end
+
+          def read_runs(io)
+            covered = 0
+            runs = []
+            while covered < point_count
+              runs << PathPointTypeRLE.new.read(io)
+              covered += runs.last.run_count
+            end
+            runs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/path_point_type.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPathPointType (2.2.2.31): flags in the high nibble, the
+        # PathPointType enumeration in the low nibble.
+        class PathPointType < Body
+          endian :little
+          uint8 :raw
+
+          def flags = raw >> 4
+          def type = raw & 0x0F
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/path_point_type_rle.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emf_plus/records/primitives/path_point_type"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPathPointTypeRLE (2.2.2.32): a Bezier bit, a reserved bit and
+        # a 6-bit run count, then the type shared by that many points.
+        class PathPointTypeRLE < Body
+          endian :little
+          uint8 :header
+          path_point_type :point_type
+
+          def bezier? = header.anybits?(0x80)
+          def run_count = header & 0x3F
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/point.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPoint (2.2.2.35): 16-bit signed, the "compressed" form.
+        class Point < Body
+          endian :little
+          int16 :x
+          int16 :y
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/point_array.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emf_plus/records/primitives/bounded_array"
+require "emf/emf_plus/records/primitives/point"
+require "emf/emf_plus/records/primitives/point_f"
+require "emf/emf_plus/records/primitives/point_r"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # `point_count` points in the form the record flags select: relative
+        # (PointR) wins over compressed (Point); otherwise PointF.
+        class PointArray < Body
+          endian :little
+          mandatory_parameter :point_count, :relative, :compressed
+          bounded_array :relative_points, type: PointR, element_size: 2, initial_length: :point_count, onlyif: -> { relative }
+          bounded_array :compressed_points, type: Point, element_size: 4, initial_length: :point_count, onlyif: lambda {
+            !relative && compressed
+          }
+          bounded_array :float_points, type: PointF, element_size: 8, initial_length: :point_count, onlyif: -> { !relative && !compressed }
+
+          def points
+            if relative
+              relative_points
+            elsif compressed
+              compressed_points
+            else
+              float_points
+            end
+          end
+
+          private
+
+          def relative = eval_parameter(:relative)
+          def compressed = eval_parameter(:compressed)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/point_f.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPointF (2.2.2.36): 32-bit floats.
+        class PointF < Body
+          endian :little
+          float32_le :x
+          float32_le :y
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/point_r.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emf_plus/records/primitives/relative_coordinate"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusPointR (2.2.2.37): relative location, each axis 7 or 15 bits.
+        class PointR < Body
+          endian :little
+          relative_coordinate :x
+          relative_coordinate :y
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/rect.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bindata"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusRect (2.2.2.39): 16-bit signed, the "compressed" form.
+        class Rect < Body
+          endian :little
+          int16 :x
+          int16 :y
+          int16 :width
+          int16 :height
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/rect_array.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/emf_plus/records/primitives/bounded_array"
+require "emf/emf_plus/records/primitives/rect"
+require "emf/emf_plus/records/primitives/rect_f"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # `rect_count` rectangles, Rect when compressed and RectF otherwise.
+        class RectArray < Body
+          endian :little
+          mandatory_parameter :rect_count, :compressed
+          bounded_array :compressed_rects, type: Rect, element_size: 8, initial_length: :rect_count, onlyif: -> { compressed }
+          bounded_array :float_rects, type: RectF, element_size: 16, initial_length: :rect_count, onlyif: -> { !compressed }
+
+          def rects = eval_parameter(:compressed) ? compressed_rects : float_rects
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/rect_f.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "bindata"
+require "emf/binary/float32_le"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusRectF (2.2.2.40): 32-bit floats.
+        class RectF < Body
+          endian :little
+          float32_le :x
+          float32_le :y
+          float32_le :width
+          float32_le :height
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/region_node.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "bindata"
+require "emf/emf_plus/records/primitives/byte_reader"
+require "emf/emf_plus/records/primitives/rect_f"
+require "emf/emf_plus/records/primitives/region_node_child_nodes"
+require "emf/emf_plus/records/primitives/region_node_path"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusRegionNode (2.2.2.40): a RegionNodeDataType, then data chosen
+        # by it: two child nodes (And/Or/Xor/Exclude/Complement), a RectF, a
+        # RegionNodePath, or nothing (Empty/Infinite).
+        class RegionNode
+          include ByteReader
+
+          COMBINING = [0x1, 0x2, 0x3, 0x4, 0x5].freeze
+          RECT = 0x10000000
+          PATH = 0x10000001
+          EMPTY = 0x10000002
+          INFINITE = 0x10000003
+          MAX_DEPTH = 256
+
+          attr_reader :type, :data
+
+          def initialize(depth = 0)
+            @depth = depth
+          end
+
+          def read(io)
+            raise BinData::ValidityError, "region nodes nested deeper than #{MAX_DEPTH} levels" if @depth > MAX_DEPTH
+
+            @type = take(io, 4, "RegionNode Type").unpack1("V")
+            @data = read_data(io)
+            self
+          end
+
+          def combining? = COMBINING.include?(type)
+          def to_binary_s = [type].pack("V") + (data ? data.to_binary_s : "".b)
+
+          # Nodes in this subtree, itself included.
+          def node_count = 1 + (combining? ? data.left.node_count + data.right.node_count : 0)
+
+          private
+
+          def read_data(io)
+            case type
+            when *COMBINING then read_children(io)
+            when RECT then RectF.new.read(io)
+            when PATH then RegionNodePath.new.read(io)
+            when EMPTY, INFINITE then nil
+            else raise BinData::ValidityError, "unknown RegionNodeDataType 0x#{type.to_s(16)}"
+            end
+          end
+
+          def read_children(io)
+            RegionNodeChildNodes.new(child(io), child(io))
+          end
+
+          def child(io) = self.class.new(@depth + 1).read(io)
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/region_node_child_nodes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusRegionNodeChildNodes (2.2.2.41): the two subtrees of a
+        # combining node. RegionNode builds it, since the subtrees are nodes.
+        class RegionNodeChildNodes
+          attr_reader :left, :right
+
+          def initialize(left, right)
+            @left = left
+            @right = right
+          end
+
+          def to_binary_s = left.to_binary_s + right.to_binary_s
+        end
+      end
+    end
+  end
+end

data/lib/emf/emf_plus/records/primitives/region_node_path.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "emf/emf_plus/records/primitives/byte_reader"
+require "emf/emf_plus/records/primitives/path"
+
+module Emf
+  module EmfPlus
+    module Records
+      module Primitives
+        # EmfPlusRegionNodePath (2.2.2.42): a byte length, then an EmfPlusPath
+        # filling it. Bytes of the length the path does not use (its
+        # alignment padding) stay in `padding`.
+        class RegionNodePath
+          include ByteReader
+
+          attr_reader :path, :padding
+
+          def read(io)
+            length = take(io, 4, "RegionNodePathLength").unpack1("l<")
+            raise BinData::ValidityError, "negative RegionNodePathLength #{length}" if length.negative?
+
+            bytes = take(io, length, "RegionNodePath of #{length} bytes")
+            @path = Path.new.read(bytes)
+            @padding = bytes.byteslice(path.num_bytes..)
+            self
+          end
+
+          def to_binary_s
+            body = path.to_binary_s + padding
+            [body.bytesize].pack("V") + body
+          end
+        end
+      end
+    end
+  end
+end