embed_xmp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c43b6512c1799531bf8eff944a39df0a9104c37efde80baae9807877e3db7e17
+  data.tar.gz: f6ebaa9ac5f3865587a530db76d11a2cc5b5b381511711eccd10ac492f27fe1a
+SHA512:
+  metadata.gz: 8b39a208756fc270088971aa8922f046ff0bf158dcbc7f8c45252fe9f62a13640437369d53b524236218c71ac3bbb84ce975338b56b7cbe344cc0bc9b33abfcf
+  data.tar.gz: 186975546220d9f5b565d1dd3db5ac64df4355a542bb0370a28cd1e3363db93dbed7657d42f4348e744fe0dd04ba86ac73d01e868d0f4b0014ac932b5e7441af

data/COPYING

@@ -0,0 +1,9 @@
+Copyright © 2020 Daniel Aleksandersen. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/bin/embed_xmp

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'embed_xmp'
+
+def usage
+  puts "Usage: #{$PROGRAM_NAME} xmp_path image_path output_image_path"
+  puts
+  puts "       XMP sidecars are checked to be well-formatted XML but aren't\n"
+  puts '       otherwise validated (whitespace is discarded!)'
+  exit 2
+end
+
+sidecar_file = ARGV[0]
+
+input_file = ARGV[1]
+output_file = ARGV[2]
+
+usage if sidecar_file.nil? || input_file.nil? || output_file.nil?
+
+raise 'XMPFileNotFound' unless File.exist?(sidecar_file)
+raise 'InputImageNotFound' unless File.exist?(input_file)
+
+unless %w[.xmp .xml].include?(File.extname(sidecar_file).downcase)
+  raise 'UnsupportedSidecarExtension'
+end
+
+in_ext = File.extname(input_file).downcase
+
+if %w[.jpeg .jpg].include?(in_ext)
+  emb = EmbedXMP::JPEG.new(input_file)
+elsif %w[.png .pnga].include?(in_ext)
+  emb = EmbedXMP::PNG.new(input_file)
+elsif %w[.svg .xml].include?(in_ext)
+  emb = EmbedXMP::SVG.new(input_file)
+elsif in_ext == '.webp'
+  emb = EmbedXMP::WebP.new(input_file)
+else
+  raise 'UnsupportedImageExtension'
+end
+
+emb.join_sidecar(sidecar_file)
+emb.write(output_file)

data/lib/embed_xmp.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'embed_xmp/xmp'
+require 'embed_xmp/jpeg'
+require 'embed_xmp/png'
+require 'embed_xmp/webp'
+require 'embed_xmp/svg'

data/lib/embed_xmp/image_file.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+class EmbedXMP
+  # Basic image file representation.
+  class ImageFile
+    @image_data
+
+    def initialize(input_image)
+      @image_data = read_io_or_string(input_image)
+    end
+
+    # Read from a readable +IO+ object or a +String+ (file path or a thing).
+    def read_io_or_string(thing)
+      if thing.respond_to?(:encoding)
+        return IO.binread(thing) if File.exist?(thing)
+
+        return thing
+      elsif thing.respond_to?(:read)
+        return IO.binread(thing)
+      end
+
+      raise 'FileNotAnIOorString'
+    end
+
+    # Insert a +chunk+ of data at +file_offset+ from the start of +file_data+.
+    def insert_into_file(offset, data)
+      @image_data = @image_data[0..offset - 1] + data + @image_data[offset..-1]
+    end
+
+    # Write image to file (or return if argument is +nil+).
+    def write(output_file, data: nil)
+      data = @image_data if data.nil?
+      return data if output_file.nil?
+
+      written_bytes = 0
+      File.open(output_file, 'wb') do |file|
+        written_bytes = file.write(data)
+      end
+
+      written_bytes > 0 && written_bytes == data.b.length
+    end
+  end
+end

data/lib/embed_xmp/jfif.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'embed_xmp/image_file'
+
+class EmbedXMP
+  # JPEG File Interchange Format (container format for JPEG)
+  class JFIF < ImageFile
+    JFIF_SOI = "\xFF\xD8".b
+    JFIF_END = "\xFF\xD9".b
+
+    # Check if file has JFIF markers.
+    def check_file_markers
+      raise 'NoJPEGStartOfFile' if JFIF_SOI != @image_data[0..1]
+      raise 'NoJPEGEndOfFile' if JFIF_END != @image_data[-2..-1]
+    end
+
+    # Return segment at +offset+ from the beginning of the file.
+    def segment(offset)
+      marker = @image_data[offset, 2]
+      length = @image_data[offset + 2, 2].b.unpack1('n') + 2
+
+      raise 'SegmentExceedFileLength' if offset + length > @image_data.length
+
+      data = @image_data[offset + 2, length]
+
+      [marker, length, data]
+    end
+
+    # Remove the chunk at +offset+ from the beginning of the file.
+    def remove_segment(offset)
+      _, length, = segment(offset)
+
+      @image_data.slice!(offset, length)
+    end
+
+    def new_segment(marker, data)
+      raise 'SegmentMarkerNotTwoBytes' if marker.length != 2
+      raise 'SegmentMarkerDoesNotBeginWithNullByte' if marker == '\b'.b
+
+      length = [2 + data.length].pack('n')
+
+      marker + length + data
+    end
+  end
+end

data/lib/embed_xmp/jpeg.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'embed_xmp/jfif'
+
+class EmbedXMP
+  # JPEG images
+  class JPEG < JFIF
+    JPEG_AP1 = "\xFF\xE1".b
+    JPEG_IMG = "\xFF\xDA".b
+    JPEG_XMP = "http://ns.adobe.com/xap/1.0/\0".b
+    JPEG_EXF = "Exif\0\0".b
+
+    # Join an XMP sidecar file into the image file.
+    def join_sidecar(sidecar_file, xpacked: false)
+      check_file_markers
+      remove_xmp
+
+      sidecar = read_io_or_string(sidecar_file)
+      xmp_chunk = create_xmp_segment(sidecar, xpacked)
+
+      insert_into_file(find_xmp_insertion_offset, xmp_chunk)
+    end
+
+    def remove_xmp
+      offset = JFIF_SOI.length
+      while offset < @image_data.length
+        marker, length, = segment(offset)
+
+        break if [JPEG_IMG, JFIF_END, nil].include?(marker)
+
+        if segment_is_app1_xmp(offset, marker)
+          remove_segment(offset)
+          next
+        end
+
+        offset += length
+      end
+    end
+
+    private
+
+    def find_xmp_insertion_offset
+      offset = JFIF_SOI.length
+      cursor = offset
+      while offset < @image_data.length
+        marker, length, = segment(offset)
+
+        break if [JPEG_IMG, JFIF_END, nil].include?(marker)
+
+        if segment_is_app1_exif(offset, marker)
+          cursor = offset + length
+          break
+        end
+
+        offset += length
+      end
+
+      cursor
+    end
+
+    def segment_is_app1_exif(off, seg)
+      JPEG_AP1 == seg && @image_data[off + 4, JPEG_EXF.length].b == JPEG_EXF
+    end
+
+    def segment_is_app1_xmp(off, seg)
+      JPEG_AP1 == seg && @image_data[off + 4, JPEG_XMP.length + 4].b == JPEG_XMP
+    end
+
+    def create_xmp_segment(xmp, xpacked)
+      data = JPEG_XMP +
+             EmbedXMP::XMP
+             .new(xmp, writable: true, xpacked: xpacked)
+             .to_s.gsub("\0", ' ')
+
+      new_segment(JPEG_AP1, data.b)
+    end
+  end
+end

data/lib/embed_xmp/png.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'digest/crc32'
+
+require 'embed_xmp/image_file'
+
+class EmbedXMP
+  # PNG images
+  class PNG < ImageFile
+    PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b.freeze
+    PNG_HEADER = 'IHDR'
+    PNG_IMAGE_END = 'IEND'
+
+    XMP_CHUNK_SIG = "iTXtXML:com.adobe.xmp\0\0\0\0\0".b.freeze
+
+    # Join an XMP sidecar file into a PNG image file.
+    def join_sidecar(sidecar_file, xpacked: false)
+      check_file_signatures
+      remove_xmp
+
+      sidecar = read_io_or_string(sidecar_file)
+      xmp_chunk = create_xmp_itxt(sidecar, xpacked)
+
+      insert_into_file(find_xmp_insertion_offset, xmp_chunk)
+    end
+
+    # Quick and dirty test to see if +png_data+ is a PNG image file
+    def check_file_signatures
+      raise 'NoPNGSignature' if PNG_SIGNATURE != @image_data[0..7]
+      raise 'NoPNGEndOfFile' if PNG_IMAGE_END != @image_data[-8..-5]
+    end
+
+    def chunk(offset)
+      chunk_length = @image_data[offset, 4].b.unpack1('N') + 12
+
+      raise 'ChunkLongerThanFile' if offset + chunk_length > @image_data.length
+
+      chunk_id = @image_data[offset + 4, 4]
+
+      data = @image_data[offset + 8, chunk_length]
+
+      [chunk_id, chunk_length, data]
+    end
+
+    # Return chunk at +offset+ from the beginning of the file.
+    def remove_chunk(offset)
+      _, chunk_length, = chunk(offset)
+
+      @image_data.slice!(offset, chunk_length)
+    end
+
+    # rubocop: disable Metrics/MethodLength
+    def remove_xmp
+      offset = PNG_SIGNATURE.length
+      while offset < @image_data.length
+        chunk_id, chunk_length, = chunk(offset)
+
+        break if [PNG_IMAGE_END, nil].include?(chunk_id)
+
+        if chunk_contains_xmp(offset)
+          remove_chunk(offset)
+          next
+        end
+
+        offset += chunk_length
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    private
+
+    def find_xmp_insertion_offset
+      offset = PNG_SIGNATURE.length
+      cursor = offset
+      while offset < @image_data.length
+        chunk_id, chunk_length, = chunk(offset)
+
+        break if [PNG_IMAGE_END, nil].include?(chunk_id)
+
+        if PNG_HEADER == chunk_id
+          cursor = offset + chunk_length
+        end
+
+        offset += chunk_length
+      end
+
+      cursor
+    end
+
+    def chunk_contains_xmp(offset)
+      XMP_CHUNK_SIG == @image_data[offset + 4, XMP_CHUNK_SIG.length + 3].b
+    end
+
+    def new_chunk(chunk_id, chunk_data)
+      length = [chunk_data.length].pack('N')
+
+      checksum = [Digest::CRC32.checksum(chunk_id + chunk_data)].pack('N')
+
+      length.b + chunk_id + chunk_data + checksum
+    end
+
+    def create_xmp_itxt(xmp_data, xpacked)
+      chunk_id = 'iTXt'
+      chunk_data = ("XML:com.adobe.xmp\0\0\0\0\0" +
+                   EmbedXMP::XMP
+                   .new(xmp_data, writable: false, xpacked: xpacked)
+                   .to_s.gsub("\0", ' ')).b
+
+      new_chunk(chunk_id, chunk_data)
+    end
+  end
+end

data/lib/embed_xmp/riff.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'embed_xmp/image_file'
+
+class EmbedXMP
+  # Resource Interchange File Format (container format for WebP)
+  class RIFF < ImageFile
+    RIFF_HEAD = 'RIFF'
+
+    # Return the RIFF file header.
+    def file_header
+      riff_id, file_length, data = chunk(0)
+      form_type = data[0, 4]
+      real_file_length = @image_data.length
+
+      raise 'NoRIFFHeader' if RIFF_HEAD != riff_id
+      raise 'FileHeaderLongerThanFile' if real_file_length != file_length
+
+      [riff_id, file_length, form_type]
+    end
+
+    # Updates the file length value in the WebP file header.
+    def update_file_length_header
+      @image_data[4, 4] = [@image_data.length - 8].pack('V')
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # Return chunk at +offset+ from the beginning of the file.
+    def chunk(offset)
+      raise 'ChunksMustBeTwoBytesAligned' if offset.odd?
+
+      chunk_id = @image_data[offset, 4]
+
+      data_length = @image_data[offset + 4, 4].b.unpack1('V')
+      chunk_length = data_length + (data_length % 2) + 8
+
+      raise 'ChunkExceedsFileLength' if offset + chunk_length > @image_data.length
+
+      data = @image_data[offset + 8, data_length]
+
+      [chunk_id, chunk_length, data]
+    end
+    # rubocop: enable Metrics/AbcSize
+
+    # Remove the chunk at +offset+ from the beginning of the file.
+    def remove_chunk(offset)
+      _, chunk_length, = chunk(offset)
+
+      @image_data.slice!(offset, chunk_length)
+
+      update_file_length_header
+    end
+
+    # Replace the chunk at +offset+ from the beginning of the file
+    # with a new chunk
+    def replace_chunk(offset, chunk_id, data)
+      remove_chunk(offset)
+
+      chunk = new_chunk(chunk_id, data)
+
+      insert_into_file(offset, chunk)
+
+      update_file_length_header
+    end
+
+    # Create a new RIFF chunk with +data+ with pad byte when needed.
+    def new_chunk(chunk_id, data)
+      unless chunk_id.match?(/[a-zA-Z0-9 ]{4}/)
+        raise 'RIFFChunkIdentifierMustBeFourChar'
+      end
+
+      data_length = data.length
+      data += '\0'.b if data_length.odd?
+
+      chunk_id.b + [data_length].pack('V') + data
+    end
+  end
+end

data/lib/embed_xmp/svg.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'nokogiri'
+
+require 'embed_xmp/image_file'
+
+class EmbedXMP
+  # SVG images
+  class SVG < ImageFile
+
+    SVG_NAMESPACE = 'http://www.w3.org/2000/svg'
+
+    def initialize(input_file)
+      file = read_io_or_string(input_file)
+      svg = Nokogiri::XML(file) do |conf|
+        conf.options = Nokogiri::XML::ParseOptions::NOBLANKS
+      end
+
+      raise 'NoSVGnamespace' if SVG_NAMESPACE != svg.root.namespace.href
+
+      @image_file = svg
+    end
+
+    # Join an XMP sidecar file into an SVG image file.
+    def join_sidecar(sidecar_file, xpacked: false)
+      remove_xmp
+
+      xmp_data = read_io_or_string(sidecar_file)
+      insert_xmp_metadata_into_svg(create_metadata(xmp_data, xpacked))
+    end
+
+    # Removes XMP metadata in /svg/metadata/rdf:RDF. Will only detect XMP data
+    # wrapped in an XPACKET processing instruction.
+    def remove_xmp
+      @image_file.root.xpath('//svg:metadata', 'svg' => 'http://www.w3.org/2000/svg')
+        .each do |svg_metadata|
+        xml_pi = svg_metadata.xpath('processing-instruction()')
+
+        if xml_pi.empty? ||
+           xml_pi.first.content != EmbedXMP::XMP::XPACKET_PDATA
+          next
+        end
+
+        svg_metadata.remove
+      end
+    end
+
+    def write(output_file)
+      data = @image_file.to_xml(encoding: 'utf-8', indent: 2)
+      super(output_file, data: data)
+    end
+
+    private
+
+    def insert_xmp_metadata_into_svg(xmp)
+      # insert <metadata> after <title> and <desc> or at top
+      insert_position = 0
+      2.times do
+        node_name = @image_file.root.children[insert_position].name
+        insert_position += 1 if %w[title desc].include?(node_name)
+      end
+
+      @image_file.root.children[insert_position].add_previous_sibling(xmp)
+    end
+
+    def create_metadata(xmp_data, xpacked)
+      xpacked_xmp = EmbedXMP::XMP
+                    .new(xmp_data, writable: true, xpacked: xpacked).to_s
+
+      data = Nokogiri::XML("<metadata>\n#{xpacked_xmp}\n</metadata>") do |conf|
+        conf.options = Nokogiri::XML::ParseOptions::NOBLANKS
+      end
+
+      data.root
+    end
+  end
+end

data/lib/embed_xmp/webp.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'embed_xmp/riff'
+
+class EmbedXMP
+  # WebP images
+  class WebP < RIFF
+    WEBP_HEAD = 'WEBP'
+    VP8X_HEAD = 'VP8X'
+    VP8F_HEAD = 'VP8 '
+    VP8L_HEAD = 'VP8L'
+    XMPS_HEAD = 'XMP '
+
+    VP8X_XMP_FLAG = 0b00000100
+
+    # Join an XMP sidecar into the image file.
+    def join_sidecar(sidecar_file, xpacked: false)
+      remove_xmp
+
+      xmp_data = read_io_or_string(sidecar_file)
+      upsert_xmp_chunk(create_xmp_chunk(xmp_data, xpacked))
+    end
+
+    def file_header
+      riff_id, file_length, form_type = super
+
+      raise 'NoWEBPHeader' if WEBP_HEAD != form_type
+
+      [riff_id, file_length, form_type]
+    end
+
+    private
+
+    # rubocop: disable Metrics/MethodLength
+    def remove_xmp
+      offset = 12
+      while offset < @image_data.length
+        chunk_id, length, = chunk(offset)
+
+        break if chunk_id.nil?
+
+        if XMPS_HEAD == chunk_id
+          remove_chunk(offset)
+          toggle_xmp_feature(xmp: false)
+          break if offset + length >= @image_data.length
+
+          next
+        end
+
+        offset += length
+      end
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    def create_xmp_chunk(xmp_data, xpacked)
+      data = EmbedXMP::XMP
+             .new(xmp_data, writable: true, xpacked: xpacked)
+             .to_s.gsub("\0", ' ').b
+
+      # pad with a potentially useful space char instead of NULL at end
+      if data.length.odd?
+        data[EmbedXMP::XMP::XPACKET_END_W] =
+          " #{EmbedXMP::XMP::XPACKET_END_W}"
+      end
+
+      new_chunk(XMPS_HEAD, data)
+    end
+
+    def upsert_xmp_chunk(xmp_chunk)
+      remove_xmp
+      @image_data += xmp_chunk
+      update_file_length_header
+      toggle_xmp_feature(xmp: true)
+    end
+
+    def dimensions_from_vp8(vp8_data)
+      width, height = vp8_data[6, 4]
+                      .unpack('vv')
+                      .map { |v| (v & 0b00111111_11111111) - 1 }
+      [width, height]
+    end
+
+    def dimensions_from_vp8_lossless(vp8_data)
+      b1, b2, b3, b4 = vp8_data[1, 4].unpack('c' * 4)
+
+      width = ((b2 & 0b0011_1111) << 8) | b1
+      height = ((b4 & 0b0011_1111) << 8) |
+               ((b2 & 0b1100_0000) >> 6) | (b3 << 2)
+      [width, height]
+    end
+
+    def dimensions_from_image_chunk(chunk_id, vp8_data)
+      case chunk_id
+      when VP8F_HEAD
+        dimensions_from_vp8(vp8_data[0, 10])
+      when VP8L_HEAD
+        dimensions_from_vp8_lossless(vp8_data[0, 10])
+      end
+    end
+
+    def upgrade_to_extended_format
+      chunk_id, _, data = chunk(12)
+
+      width, height = dimensions_from_image_chunk(chunk_id, data)
+
+      vp8x_data = [VP8X_XMP_FLAG, 0, 0, 0,
+                   width,  width  >> 8, 0,
+                   height, height >> 8, 0].pack('c' * 10)
+
+      chunk = new_chunk(VP8X_HEAD, vp8x_data)
+
+      insert_into_file(12, chunk)
+    end
+
+    def toggle_xmp_feature(xmp: true)
+      chunk_id, _, data = chunk(12)
+
+      if VP8X_HEAD != chunk_id
+        upgrade_to_extended_format
+        return toggle_xmp_feature(xmp: xmp)
+      end
+
+      data[0] = (data.unpack1('c').to_i |  VP8X_XMP_FLAG).chr if xmp
+      data[0] = (data.unpack1('c').to_i & ~VP8X_XMP_FLAG).chr unless xmp
+
+      replace_chunk(12, chunk_id, data)
+    end
+  end
+end

data/lib/embed_xmp/xmp.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Copyright 2020 Daniel Aleksandersen <https://www.daniel.priv.no/>
+# SPDX-License-Identifier: BSD-3-Clause
+# License-Filename: COPYING
+
+require 'nokogiri'
+
+require 'embed_xmp/image_file'
+
+class EmbedXMP
+  # XMP sidecars
+  class XMP
+    XPACKET_PDATA = "begin=\"\uFEFF\" id=\"W5M0MpCehiHzreSzNTczkc9d\""
+    XPACKET_START = "<?xpacket #{XPACKET_PDATA}?>"
+    XPACKET_END_R = '<?xpacket end="r"?>'
+    XPACKET_END_W = '<?xpacket end="w"?>'
+
+    @xmp
+
+    def initialize(xmp_data_blob, writable: false, xpacked: false)
+      @xmp = xmp_str = xmp_xml_to_str(xmp_data_blob)
+
+      @xmp = xpack_sidecar(xmp_str, writable: writable) unless xpacked
+    end
+
+    # Return XMP sidecar as +String+.
+    def to_s
+      xmp_xml_to_str(@xmp)
+    end
+
+    # Read XML-formatted XMP data into a format suitable for embedding.
+    def xmp_xml_to_str(xmp_data)
+      xmp = Nokogiri::XML(xmp_data) do |conf|
+        conf.options = Nokogiri::XML::ParseOptions::NOBLANKS
+      end
+
+      raise 'XMPIsMalformedXML' unless xmp.errors.empty?
+
+      xmp.to_xml(indent: 0,
+                 encoding: 'utf-8',
+                 save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
+    end
+
+    # Wrap XMP sidecar data in in an magic XML processing instruction (xpacket).
+    # +writable+ is approperiate for file formats where the XMP data can be
+    # modified in place by staying within the confines of the XPACKET. (E.g.
+    # file formats with no chunk checksums.)
+    def xpack_sidecar(xmp_data, writable: false)
+      xpacket_end = writable ? XPACKET_END_W : XPACKET_END_R
+
+      "#{XPACKET_START}\n#{xmp_data}\n#{xpacket_end}"
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: embed_xmp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Aleksandersen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: digest-crc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description: Embed XMP sidecar files into image files.
+email: code@daniel.priv.no
+executables:
+- embed_xmp
+extensions: []
+extra_rdoc_files:
+- COPYING
+files:
+- COPYING
+- bin/embed_xmp
+- lib/embed_xmp.rb
+- lib/embed_xmp/image_file.rb
+- lib/embed_xmp/jfif.rb
+- lib/embed_xmp/jpeg.rb
+- lib/embed_xmp/png.rb
+- lib/embed_xmp/riff.rb
+- lib/embed_xmp/svg.rb
+- lib/embed_xmp/webp.rb
+- lib/embed_xmp/xmp.rb
+homepage: 
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: XMP sidecar embedder.
+test_files: []