Recent from talks
Nothing was collected or created yet.
Extensible Metadata Platform
View on WikipediaThis article needs additional citations for verification. (November 2016) |
| Extensible Metadata Platform | |
|---|---|
XMP logo | |
| Abbreviation | XMP |
| Latest version | ISO 16684-1:2019 part 1 & ISO 16684-2:2014 part 2 22 December 2014 |
| Domain | Metadata |
| Website | www |
The Extensible Metadata Platform (XMP) is an ISO standard, originally created by Adobe Systems Inc., for the creation, processing and interchange of standardized and custom metadata for digital documents and data sets.
XMP standardizes a data model, a serialization format and core properties for the definition and processing of extensible metadata. It also provides guidelines for embedding XMP information into popular image, video and document file formats, such as JPEG and PDF, without breaking their readability by applications that do not support XMP. Therefore, the non-XMP metadata have to be reconciled with the XMP properties. Although metadata can alternatively be stored in a sidecar file, embedding metadata avoids problems that occur when metadata is stored separately.
The XMP data model, serialization format and core properties is published by the International Organization for Standardization as ISO 16684-1:2012 standard.[1]
Data model
[edit]The defined XMP data model can be used to store any set of metadata properties. These can be simple name/value pairs, structured values or lists of values. The data can be nested as well. The XMP standard also defines particular namespaces for defined sets of core properties (e.g. a namespace for the Dublin Core Metadata Element Set). Custom namespaces can be used to extend the data model.
An instance of the XMP data model is called an XMP packet. Adding properties to a packet does not affect existing properties. Software to add or modify properties in an XMP packet should leave properties that are unknown to it untouched.
For example, it is useful for recording the history of a resource as it passes through multiple processing steps, from being photographed, scanned, or authored as text, through photo editing steps (such as cropping or color adjustment), to assemble into a final document. XMP allows each software program or device along the workflow to add its own information to a digital resource, which carries its metadata along. The prerequisite is that all involved editors either actively support XMP, or at least do not delete it from the resource. [2]
Serialization
[edit]The abstract XMP data model needs a concrete representation when it is stored or embedded into a file. As serialization format, a subset of the W3C RDF/XML syntax is most commonly used. It is a syntax to express a Resource Description Framework graph in XML. There are various equivalent ways to serialize the same XMP packet in RDF/XML.
The most common metadata tags recorded in XMP data are those from the Dublin Core Metadata Initiative, which include things like title, description, creator, and so on. The standard is designed to be extensible, allowing users to add their own custom types of metadata into the XMP data. XMP generally does not allow binary data types to be embedded. This means that any binary data one wants to carry in XMP, such as thumbnail images, must be encoded in some XML-friendly format, such as Base64.
XMP metadata can describe a document as a whole (the "main" metadata), but can also describe parts of a document, such as pages or included images. This architecture makes it possible to retain authorship and rights information about, for example, images included in a published document. Similarly, it permits documents created from several smaller documents to retain the original metadata associated with the parts.[2]
Example
[edit]This is an example XML document for serialized XMP metadata in a JPEG photo:
<?xpacket begin="?" id="W5M0MpCehiHzreSzNTczkc9d"?>
<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.4-c002 1.000000, 0000/00/00-00:00:00 ">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:xmp="http://ns.adobe.com/xap/1.0/">
<xmp:CreatorTool>Picasa</xmp:CreatorTool>
</rdf:Description>
<rdf:Description rdf:about=""
xmlns:mwg-rs="http://www.metadataworkinggroup.com/schemas/regions/"
xmlns:stDim="http://ns.adobe.com/xap/1.0/sType/Dimensions#"
xmlns:stArea="http://ns.adobe.com/xmp/sType/Area#">
<mwg-rs:Regions rdf:parseType="Resource">
<mwg-rs:AppliedToDimensions rdf:parseType="Resource">
<stDim:w>912</stDim:w>
<stDim:h>687</stDim:h>
<stDim:unit>pixel</stDim:unit>
</mwg-rs:AppliedToDimensions>
<mwg-rs:RegionList>
<rdf:Bag>
<rdf:li rdf:parseType="Resource">
<mwg-rs:Type></mwg-rs:Type>
<mwg-rs:Area rdf:parseType="Resource">
<stArea:x>0.680921052631579</stArea:x>
<stArea:y>0.3537117903930131</stArea:y>
<stArea:h>0.4264919941775837</stArea:h>
<stArea:w>0.32127192982456143</stArea:w>
<stArea:unit>normalized</stArea:unit>
</mwg-rs:Area>
</rdf:li>
</rdf:Bag>
</mwg-rs:RegionList>
</mwg-rs:Regions>
</rdf:Description>
<rdf:Description rdf:about=""
xmlns:exif="http://ns.adobe.com/exif/1.0/">
<exif:PixelXDimension>912</exif:PixelXDimension>
<exif:PixelYDimension>687</exif:PixelYDimension>
<exif:ExifVersion>0220</exif:ExifVersion>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
<!-- whitespace padding -->
<?xpacket end="w"?>
This metadata describes various properties of the image like the creator tool, image dimension or a face region[3] within the image.
Embedding
[edit]Embedding metadata in files allows easy sharing and transfer of files across products, vendors, platforms, without metadata getting lost. Embedding avoids a multitude of problems coming from proprietary vendor-specific metadata databases.
XMP can be used in several file formats such as PDF, JPEG, JPEG 2000, JPEG XR, JPEG XL, GIF, PNG, WebP, HTML, TIFF, Adobe Illustrator, PSD, MP3, MP4, Audio Video Interleave, WAV, RF64, Audio Interchange File Format, PostScript, Encapsulated PostScript, and proposed for DjVu. In a typical edited JPEG file, XMP information is typically included alongside Exif and IPTC Information Interchange Model data.
Location in file types
[edit]For more details, the XMP Specification, Part 3 Storage in Files listed below has details on embedding in specific file formats.
- TIFF – Tag 700
- JPEG – Application segment 1 (0xFFE1) with segment header "http://ns.adobe.com/xap/1.0/\x00"
- JPEG 2000 – "uuid" atom with UID of 0xBE7ACFCB97A942E89C71999491E3AFAC
- JPEG XL – "xml " box type
- PNG – inside an "iTXt" text block with the keyword "XML:com.adobe.xmp"
- GIF – as an Application Extension with identifier "XMP Data" and authentication code "XMP"
- MP3 – inside the ID3 block as a "PRIV" frame with an owner identifier of "XMP".
- MP4 – top-level "UUID" box with the UUID 0xBE7ACFCB97A942E89C71999491E3AFAC (Same as JPEG 2000)
- MOV (QuickTime) – "XMP_" atom within a "udta" atom, within a top level "moov" atom.
- PDF – embedded in a metadata stream contained in a PDF object
- WebP – inside the file's XMP chunk
- For file formats that have no support for embedded XMP data, this data can be stored in external .xmp sidecar files.
Support and acceptance
[edit]XMP Toolkit
[edit]The XMP Toolkit implements metadata handling in two libraries:
- XMPCore for creation and manipulation of metadata that follows the XMP Data Model.
- XMPFiles for embedding serialized metadata in files, and for retrieving embedded metadata.
Adobe provides the XMP Toolkit free of charge under a BSD license.[4][2] The Toolkit includes specification and usage documents (PDFs), API documentation (doxygen/javadoc), C++ source code (XMPCore and XMPFiles) and Java source code (currently only XMPCore). XMPFiles is currently available as a C++/Java implementation in Windows, Mac OS, Unix/Linux.[citation needed]
Free software and open-source tools (read/write support)
[edit]- Alfresco - open source CMS, DAM component can read/write XMP (Microsoft Windows, Linux)
- Calibre by Kovid Goyal, an ebook management system that can read and write XMP metadata from some file formats
- CC PDF Converter - A free open source (GPL) program to convert documents to PDF with embedded Creative-Commons license (Microsoft Windows).
- darktable - RAW developer, can read/write XMP in supported file formats (Linux, Mac OS X, Microsoft Windows, BSD)
- digiKam - open source (GPL) image tagger and organiser (Linux, Mac OS X, Microsoft Windows)
- ExifTool by Phil Harvey, open source Perl module or command line. Can read/write XMP, supports custom XMP schema (platform independent)
- F-Spot - Linux/GNOME photo manager and editor
- Geeqie - Lightweight Gtk+ based image manager (formerly GQView)
- GIMP - GNU Image Manipulation Program
- Gwenview - Linux/KDE photo manager and editor
- iText - Open Source Java library that can read and write XMP embedded in PDF files.
- Magic Lantern (firmware) - A firmware add-on for various Canon Digital single-lens reflex (DSLR) cameras, allowing writing of XMP sidecar files including exposure compensation information for post-deflicker.
- RawTherapee - Can read "rating" tags from embedded XMP, which are then shown in the File Browser/Filmstrip using RawTherapee's star rating system.
- Shotwell - Linux/GNOME photo manager, can read/write Exif, IPTC and XMP metadata
- TYPO3 - open source Enterprise CMS. DAM component reads XMP (PHP based)
Proprietary tools (read/write support)
[edit]- ACDSee Pro can read and write XMP information for DNG, GIF, JPEG, PNG and TIFF files (Microsoft Windows, Mac OS X).
- Acrobat - can read and write XMP in PDF files (Microsoft Windows, Mac OS X, partially Linux).
- Aperture - Image management application and RAW developer. Reads/writes XMP sidecar files to (batch) import/export image metadata (Mac OS X).
- Bibble5 can read/write XMP information for RAW, JPG and TIFF files (Microsoft Windows, Mac OS X, Linux).
- Bridge - can read/write and batch edit XMP metadata (Microsoft Windows, Mac OS X)
- Capture One - Photo editing and management software. Reads and writes XMP for all supported image formats (Microsoft Windows, Mac OS X).
- Corel AfterShot Pro - RAW processor (Bibble successor), reads/writes XMP, uses XMP sidecar files for non-destructive image processing (Microsoft Windows, Mac OS X, Linux).
- Cumulus - DAM software, can read/write XMP for all supported image formats, InDesign and PDF files (Microsoft Windows, Mac OS X, Linux)
- DBGallery - Can read/write XMP for JPEG, PSD, RAW, TIFF, DNG, PNG, GIF, JP2, PJX, MPG, MP4, MPEG, MOV (Microsoft Windows). Multi-user, central database system.
- FastPictureViewer - Image viewer (Windows) with XMP embedding and/or sidecar files creation (xmp:Rating, xmp:Label, photoshop:Urgency) (Microsoft Windows)
- FrameMaker - publishing tool. Stores document metadata in XMP since version 7.0 (Microsoft Windows)
- Illustrator - illustration software, writes document metadata in XMP (Microsoft Windows, Mac OS X)
- Indesign - page layout software, can pass through XMP in placed objects, writes extensive XMP about document contents in layout documents and exported PDF (Microsoft Windows, Mac OS X)
- iOS Photos app - Saves edits made to photos on an iPhone/iPad losslessly as XMP embedded in the original JPEG.[5]
- Lightroom - Image management application and RAW developer. Uses XMP for non-destructive image manipulation and import/export of metadata (Microsoft Windows, Mac OS X)
- Microsoft Windows Vista - Photo Gallery saves tags to XMP (Microsoft Windows)
- Photo Mechanic - Reads and writes XMP directly into image files or into XMP sidecar files.
- Photoshop - can read/write XMP in supported images. Allows embedding of non standard XMP data through 'custom XMP panels' (Microsoft Windows, Mac OS X)
- PicaJet - Can read XMP for JPG, TIFF and DNG formats (Microsoft Windows).
- Picasa - Image organizer/viewer, uses XMP for face tagging (Microsoft Windows, Mac OS X, Linux)
- PixelPeeper - can read Exif and XMP metadata from JPG files. Also, it can turn XMP metadata into Lightroom-compatible presets.
- Portfolio - DAM software, can read/write XMP in supported file formats (Microsoft Windows, Mac OS X)
- Stibo STEP - DAM component reads/writes XMP for all supported formats
- Windows Imaging Component - Microsoft library for working with and processing digital images and image metadata (Microsoft Windows)
- Windows Live Photo Gallery - a photo management and sharing application released as a part of Microsoft's Windows Live initiative. It is an upgraded version of Windows Photo Gallery, which is a part of Windows Vista.
- XnView - can read/write Exif, IPTC and XMP information.
- Zoner Photo Studio - can read/write Exif, IPTC and XMP information for DNG, JPEG, TIFF, HDP and various RAW files (Microsoft Windows).
The mainstream IPTC Information Interchange Model editing tools also support editing of XMP data.
Licensing
[edit]XMP is a registered trademark of Adobe Systems Incorporated. The XMP specification became an ISO standard and is not proprietary anymore.
Initially, Adobe released source code for the XMP SDK under a license called the ADOBE SYSTEMS INCORPORATED — OPEN SOURCE LICENSE. The compatibility of this license with the GNU General Public License has been questioned.[6] The license is not listed on the list maintained by the Open Source Initiative and is different from the licenses for most of their open source software.[7]
On May 14, 2007, Adobe released the XMP Toolkit SDK under a standard BSD license.[4][2]
On August 28, 2008, Adobe posted a public patent license for the XMP.[8]As of November 2016,[update] Adobe continues to distribute these documents under the XMP Specification Public Patent License.[2]
History
[edit]XMP was first introduced by Adobe in April 2001 as part of the Adobe Acrobat 5.0 software product.[9] Before that, it was called XAP (Extensible Authoring and Publishing) as internal code name.[10]
On June 21, 2004, Adobe announced its collaboration with the International Press Telecommunications Council. In July 2004, a working group led by Adobe Systems' Gunar Penikis and IPTC's Michael Steidl was set up, and volunteers were recruited from AFP (Agence France-Presse), Associated Press, ControlledVocabulary.com, IDEAlliance, Mainichi Shimbun, Reuters, and others, to develop the new schema.[citation needed]
The "IPTC Core Schema for XMP" version 1.0 specification was released publicly on March 21, 2005. A set of custom panels for Adobe Photoshop CS can be downloaded from the IPTC. The package includes a User's Guide, example photos with embedded XMP information, the specification document, and an implementation guide for developers.[citation needed] The "User's Guide to the IPTC Core" goes into detail about how each of the fields should be used and is also available directly as a PDF.[11] The next version of the Adobe Creative Suite (CS2) included these custom panels as part of its default set.[citation needed]
The Windows Photo Gallery, released with Windows Vista, offers support for the XMP standard, the first time Microsoft has released metadata compatibility beyond Exif.[12]
See also
[edit]References
[edit]- ^ Gasiorowski-Denis, Elizabeth (22 March 2012). "Adobe Extensible Metadata Platform (XMP) becomes an ISO standard". ISO. Archived from the original on 26 May 2016. Retrieved 8 August 2012.
- ^ a b c d e "Adobe XMP Developer Center". Adobe Developer Connection. Retrieved 28 November 2016.
- ^ "Guidelines For Handling Image Metadata" (PDF). Metadata Working Group. pp. 51–59.
- ^ a b Penikis, Gunar (14 May 2007). "XMP 4.1.1 SDK available under BSD license". From Gunar. Adobe.
- ^ "iOS: Edited photos show original photo after import or in other apps". Apple. 8 November 2014. Archived from the original on 2014-12-01.
- ^ Linksvayer, Mike (11 April 2005). ""Adobe Open Source License" GPL compatible?". gnu-misc-discuss (Mailing list).
- ^ "Adobe Systems Incorporated Open Source License". Adobe. Archived from the original (TXT) on 2006-12-11. Retrieved 2006-11-06.
- ^ Penikis, Gunar (28 August 2008). "Public Patent License for XMP". From Gunar. Adobe.
- ^ Cover, Robin. "Extensible Metadata Platform". xml.coverpages.org. Retrieved 2022-05-22.
- ^ Hammond, Tony. "The Name's The Thing". www.crossref.org. Retrieved 2024-05-10.
- ^ Riecks, David (16 March 2005). ""IPTC Core" Schema for XMP Version 1.0 Supplemental documentation: Custom Panels User Guide" (PDF). IPTC.
- ^ Bott, Ed (30 January 2007). "Windows Vista's three killer features". Ed Bott's Microsoft Report. ZDNet. Archived from the original on 2007-02-06.
External links
[edit]- Adobe XMP Main Page
- XMP Specification
- XMP Information on coverpages.org
- Creative Commons XMP Recommendation
- Metadata section in the PDF 1.6 Language Reference
- IPTC4XMP (IPTC Core) standard
- Metadata Working Group provides guidance on metadata interoperability Archived 2009-09-16 at the Wayback Machine
Extensible Metadata Platform
View on GrokipediaOverview
Definition and Purpose
The Extensible Metadata Platform (XMP) is an ISO-standardized framework (ISO 16684) originally developed by Adobe Systems for the creation, processing, and interchange of metadata in digital files.[5] It provides a standardized labeling technology that embeds descriptive data directly into files during content creation, enabling seamless metadata handling across diverse applications and workflows.[1] The primary purpose of XMP is to facilitate standardized metadata embedding in digital assets, supporting key processes such as digital asset management, rights management, and enhanced searchability in multimedia environments.[3] By allowing metadata like author details, keywords, and licensing information to be attached without modifying the file's core content, XMP promotes interoperability and efficient content interchange between tools and platforms.[5] This extensible approach ensures that metadata remains portable and accessible throughout the asset lifecycle.[8] Introduced by Adobe in 2001 as part of Acrobat 5.0, XMP was designed to unify disparate metadata schemes, including EXIF for image data, IPTC for news photography, and Dublin Core for general resource description, thereby addressing fragmentation in metadata standards.[9][2] At its core, XMP leverages RDF as an underlying model and XML for serialization to achieve this flexibility.[8]Key Features and Benefits
The Extensible Metadata Platform (XMP) offers extensibility through its support for custom schemas and namespaces, enabling users to define application-specific metadata without rebuilding existing systems. This feature allows for the integration of arbitrary data into media files, accommodating diverse workflows in creative industries.[3] XMP promotes interoperability by unifying multiple metadata standards, such as IPTC and EXIF, into a single RDF-based model, ensuring cross-platform consistency and a standard tagging method across Adobe and third-party products. Standardized as ISO 16684-1 since 2012, it facilitates industry-wide data exchange on open standards.[3][1] Embedding capabilities in XMP allow metadata to be stored directly within files during content creation, surviving format conversions and supporting real-time editing without altering the original file data, thus maintaining its non-destructive nature. This ensures metadata integrity throughout the asset lifecycle.[3][1] Key benefits of XMP include enhanced searchability and retrieval of rich media across diverse file formats and databases, reducing data silos in creative workflows. It automates rights management, such as through integration with Creative Commons licenses via the XMP rights schema, capturing author, copyright, and licensing details efficiently. As of 2025, XMP supports AI-driven content analysis in platforms like Adobe Experience Manager Assets, where AI automatically generates metadata fields like titles and keywords to boost discoverability and management.[3][10][11]Data Model
Core Components
The Extensible Metadata Platform (XMP) data model is fundamentally based on the Resource Description Framework (RDF), which represents metadata as a set of statements in the form of subject-predicate-object triples.[12] In this structure, the subject identifies the resource (typically the file or asset being described), the predicate specifies a property or relationship, and the object provides the value or target of that relationship.[12] This triple-based approach enables flexible, graph-like interconnections of metadata, allowing for extensible descriptions beyond predefined schemas.[12] At the core of the XMP model are properties, which encapsulate metadata attributes attached to resources. Simple properties hold basic values such as strings or numbers directly, while structured properties consist of named fields that can represent complex data like addresses or contact information, with the order of fields being insignificant.[12] These properties form the building blocks for describing resources, supporting both atomic data and hierarchical compositions.[12] To handle multiple values, XMP employs RDF collections: bags for unordered lists of items (useful for sets without inherent sequence), sequences for ordered lists where the position matters (such as timestamps or steps in a process), and alternatives for ordered lists of variant options, where the first item serves as the default (e.g., translations in different languages).[12] These collection types allow properties to aggregate diverse or repetitive data logically within the model.[12] XMP supports a range of value types to accommodate various data needs, including text as Unicode strings, integers as signed or unsigned decimal representations, dates in W3C profile format (e.g., YYYY-MM-DDThh:mm:ss with timezone), booleans as "true" or "false", and real numbers for rational or floating-point values.[12] Complex nested structures are enabled by combining structured properties and collections, permitting arbitrary depth in metadata hierarchies without predefined limits.[12] Metadata in XMP is organized into self-contained packets, each representing a complete set of unique properties describing a single resource, ensuring that all relevant descriptive information is bundled together for portability and integrity.[12] These packets form the logical unit for metadata management, independent of any specific serialization.[12]RDF Integration and Namespaces
The Extensible Metadata Platform (XMP) integrates the Resource Description Framework (RDF) as its foundational data model, enabling a structured representation of metadata that aligns with semantic web principles. Specifically, XMP employs a subset of RDF, serialized in RDF/XML format, to ensure compatibility with broader RDF-based systems while imposing restrictions for practical file metadata use, such as requiring explicit arrays for multi-valued properties likedc:creator instead of repeated elements.[12] This integration allows XMP metadata to be processed by RDF tools, with properties mapped using elements like rdf:RDF and rdf:Description, and attributes such as rdf:about to denote resources, thereby supporting semantic interoperability without full adherence to unrestricted RDF syntax.[12][13]
Properties in XMP are defined and identified via Uniform Resource Identifiers (URIs) within namespaces, ensuring global uniqueness and extensibility for custom metadata schemas. For instance, core properties draw from established vocabularies like the Dublin Core Metadata Initiative, using the namespace URI http://purl.org/dc/elements/1.1/ to qualify terms such as dc:title.[12][14] This URI-based approach facilitates semantic richness by allowing properties to reference external ontologies, promoting reuse across applications while avoiding name collisions through precise scoping.[12]
Namespaces in XMP are managed through XML namespace declarations, using prefixes to qualify property names and prevent conflicts in extensible environments. Standard prefixes include dc: for Dublin Core elements, xmp: for XMP core properties, and rdf: for RDF syntax, declared via xmlns: attributes in the XML structure, such as xmlns:dc="http://purl.org/dc/elements/1.1/".[12] Custom namespaces enable proprietary or domain-specific extensions, requiring developers to use unique URIs—typically domain-based and terminated with / or #—to maintain interoperability and avoid ambiguities during RDF triple generation.[12][15]
XMP schemas for custom properties are primarily defined through documentation rather than formal XML Schema or RDF Schema definitions, emphasizing self-describing namespace URIs for validation and interoperability.[12] This approach allows processors to handle unknown properties gracefully without requiring schema awareness, though informal validation can be achieved by wrapping XMP in CDATA sections for general XML parsing.[12] In multi-namespace packets, conflicts are mitigated by organizing schemas into distinct rdf:Description elements within a single RDF graph, ensuring each namespace operates independently while sharing the same resource context.[12] For scenarios involving multiple potential packets per resource, prioritization follows guidelines like selecting the most recent via xmp:MetadataDate or using manifests like xmpMM:Manifest to resolve the primary one.[12]
Serialization
XML Format Specifications
The Extensible Metadata Platform (XMP) serializes its RDF-based data model into XML format, using a structured representation that ensures interoperability across applications and file formats.[4] The serialization follows a specific syntax where the root element is<x:xmpmeta>, which encapsulates a single <rdf:RDF> wrapper element containing one or more <rdf:Description> elements to describe the metadata properties.[16] This structure adheres to the RDF/XML syntax as defined in the RDF 1.0 Recommendation, with XMP imposing additional constraints to simplify processing, such as requiring explicit array types like <rdf:Bag> for multi-valued properties instead of repeating elements.[13]
Namespace declarations are mandatory and appear as xmlns: attributes on the <x:xmpmeta> or <rdf:Description> elements, using preferred prefixes for core schemas (e.g., xmlns:dc="http://purl.org/dc/elements/1.1/" for Dublin Core).[16] Namespace URIs must terminate with a slash (/) or hash (#) to prevent parsing ambiguities, and all XML must conform to XML 1.0 well-formedness rules, including proper entity escaping and attribute quoting.[16] Encoding is UTF-8 (or other Unicode encodings such as UTF-16 or UTF-32), declared via the XML prolog (e.g., <?xml version="1.0" encoding="UTF-8"?>), ensuring support for international characters and localization without mixed encodings within a single packet.[16]
Validation of XMP XML requires conformance to XML 1.0 syntax, RDF 1.0 serialization grammar, and XMP-specific guidelines outlined in ISO 16684-1:2019, which can be checked using tools like the W3C RDF Validator or RELAX NG schemas for XMP structures.[13] XMP properties are wrapped in CDATA sections where necessary to handle complex values, and parsers must ignore unrecognized elements while preserving the document's integrity.[16]
For versioning, the XMP packet includes the x:xmptk attribute within the <x:xmpmeta> element to indicate the Adobe XMP Toolkit version used for serialization (e.g., xmptk="Adobe XMP Core 5.6-c140 79.160451", allowing applications to assess compatibility.[16] Additionally, properties like xmpmm:DocumentID from the XMP Media Management schema provide tracking for document instances across edits, though they do not define the overall XMP format version, which is governed by the ISO 16684 series.[4]
Packet Structure and Examples
The XMP packet is the serialized form of XMP metadata, consisting of an optional header, the core metadata block in RDF/XML format, and a trailer, designed to facilitate embedding within various file formats while allowing for efficient parsing and editing. The header begins with the processing instruction<?xpacket begin="..." id="W5M0MpCehiHzreSzNTczkc9d"?>, where the begin attribute may include a byte-order mark (BOM) such as U+FEFF for Unicode support, and the id attribute provides a fixed identifier to mark the start of the packet. The metadata block follows, typically wrapped in an <x:xmpmeta> element with the namespace xmlns:x="adobe:ns:meta/", containing an <rdf:RDF> root element that holds one or more <rdf:Description> nodes representing the resource's properties. The trailer concludes the packet with <?xpacket end="w"?> for writable packets or <?xpacket end="r"?> for read-only ones, with no internal whitespace permitted in the trailer to ensure precise boundary detection.[17]
To support in-place editing without file restructuring, XMP packets include padding, typically around 2000 bytes of XML-compatible whitespace (e.g., spaces) between the metadata block and trailer, though no strict upper size limit is imposed beyond format-specific constraints like the 65,502-byte maximum for JPEG APP1 markers. Escaping rules adhere to standard RDF/XML serialization, requiring special characters in property values—such as <, >, &, and quotes—to be encoded as XML entities (e.g., <, >, &, ") to prevent parsing errors; use of CDATA sections is possible but discouraged due to the unescapable sequence ]]>. Variations in packet structure accommodate complex data types, such as arrays via <rdf:Bag>, <rdf:Seq>, or <rdf:Alt> containers with <rdf:li> child elements, and nested resources through embedded <rdf:Description> nodes within structures. Common pitfalls include failing to encode special characters properly, which can corrupt the XML, or neglecting padding, leading to inefficient updates in tools like Adobe applications.[17][18]
A simple example of an XMP packet for an image might include the Dublin Core title, the XMP CreatorTool, and a custom namespace property, serialized as follows:
<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
<x:xmpmeta xmlns:x="adobe:ns:meta/">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:dc="http://purl.org/dc/elements/1.1/">
<dc:title>
<rdf:Alt>
<rdf:li xml:lang="x-default">Sample Image Title</rdf:li>
</rdf:Alt>
</dc:title>
</rdf:Description>
<rdf:Description rdf:about=""
xmlns:xmp="http://ns.adobe.com/xap/1.0/">
<xmp:CreatorTool>Adobe Photoshop CC</xmp:CreatorTool>
</rdf:Description>
<rdf:Description rdf:about=""
xmlns:ex="http://example.com/custom/1.0/">
<ex:CustomProperty>Custom Value with & special chars</ex:CustomProperty>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
<?xpacket end="w"?>[padding whitespace]
<?xpacket begin="" id="W5M0MpCehiHzreSzNTczkc9d"?>
<x:xmpmeta xmlns:x="adobe:ns:meta/">
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about=""
xmlns:dc="http://purl.org/dc/elements/1.1/">
<dc:title>
<rdf:Alt>
<rdf:li xml:lang="x-default">Sample Image Title</rdf:li>
</rdf:Alt>
</dc:title>
</rdf:Description>
<rdf:Description rdf:about=""
xmlns:xmp="http://ns.adobe.com/xap/1.0/">
<xmp:CreatorTool>Adobe Photoshop CC</xmp:CreatorTool>
</rdf:Description>
<rdf:Description rdf:about=""
xmlns:ex="http://example.com/custom/1.0/">
<ex:CustomProperty>Custom Value with & special chars</ex:CustomProperty>
</rdf:Description>
</rdf:RDF>
</x:xmpmeta>
<?xpacket end="w"?>[padding whitespace]
<rdf:Bag> is used to represent an unordered collection:
<dc:subject>
<rdf:Bag>
<rdf:li>landscape</rdf:li>
<rdf:li>photography</rdf:li>
<rdf:li>outdoors</rdf:li>
</rdf:Bag>
</dc:subject>
<dc:subject>
<rdf:Bag>
<rdf:li>landscape</rdf:li>
<rdf:li>photography</rdf:li>
<rdf:li>outdoors</rdf:li>
</rdf:Bag>
</dc:subject>
<rdf:Description>:
<xmpMM:DerivedFrom>
<rdf:Description rdf:about="uuid:some-uuid">
<stRef:instanceID>original-image-id</stRef:instanceID>
<stRef:documentID>original-doc-id</stRef:documentID>
</rdf:Description>
</xmpMM:DerivedFrom>
<xmpMM:DerivedFrom>
<rdf:Description rdf:about="uuid:some-uuid">
<stRef:instanceID>original-image-id</stRef:instanceID>
<stRef:documentID>original-doc-id</stRef:documentID>
</rdf:Description>
</xmpMM:DerivedFrom>
<rdf:RDF> block, ensuring hierarchical data representation without violating XML well-formedness.[18]
Embedding
Embedding Mechanisms
The Extensible Metadata Platform (XMP) employs multiple mechanisms to embed metadata into digital files, ensuring that the process does not corrupt the file's primary content or structure. Primary methods include the use of sidecar files, direct embedding within file headers or footers, and storage in resource forks on macOS. Sidecar files store XMP as standalone XML documents with a .xmp extension, positioned alongside the main file to maintain a loose association without modifying the original data; this approach is particularly useful for formats lacking native embedding support, such as certain video packages.[19] Direct embedding leverages format-specific extension points, such as application markers in image files or metadata streams in documents, to insert XMP packets contiguously while adhering to the file's structural rules.[19] On macOS, XMP can alternatively be placed in the file's resource fork, supported via extended attributes on APFS filesystems, which isolates metadata in a separate data compartment from the primary data fork.[19] To facilitate binary-safe embedding across diverse file types, XMP packets are serialized as UTF-8 encoded XML and wrapped with standardized delimiters that clearly bound the metadata, preventing interference with surrounding binary data. The packet begins with<?xpacket begin="", id="W5M0MpCehiHzreSzNTczkc9d?>"? > (including a byte-order mark for encoding detection) and ends with <?xpacket end="w"?>, followed by optional padding to align with format requirements like 2-byte boundaries.[19] This structure, detailed in the XMP serialization specifications, ensures the packet remains intact during file parsing and avoids null bytes or conflicting sequences that could disrupt the host format.[12]
Updating embedded XMP involves either incrementally appending or replacing packets while preserving the file's native metadata and overall integrity. For constrained formats, such as JPEG where segments are limited to 64 KB, oversized packets are divided into a standard portion and one or more extended portions, interconnected via a 128-bit GUID (computed as an MD5 digest of the extended data) to enable reassembly and verify completeness.[19] This process requires careful handling to maintain compatibility with legacy applications that may ignore or mishandle XMP.
XMP metadata is inherently non-executable, functioning solely as descriptive, structured data without mechanisms for code execution or dynamic behavior.[12] Nonetheless, embedding in untrusted files introduces potential security risks, including the injection of malicious identifiers or tracking elements that could enable attribution in malware campaigns or expose processing applications to unintended data leaks if parsers fail to validate inputs securely.[20]
Supported File Formats and Locations
The Extensible Metadata Platform (XMP) enables embedding of standardized metadata into a wide range of file formats, ensuring compatibility and preservation during file handling and conversion. In image formats, XMP is supported in JPEG files via the APP1 marker segment, prefixed with the namespace "http://ns.adobe.com/xap/1.0/\0" and encoded in UTF-8, allowing up to 65,502 bytes in the standard packet with extended support using additional APP1 segments identified by a dynamic 128-bit MD5 GUID (digest of the extended packet content) for larger payloads.[21] TIFF files accommodate XMP through Image File Directory (IFD) tag 700 (0x2BC) in the 0th IFD, where a 12-byte entry points to the UTF-8 encoded packet via an offset.[21] PNG files utilize the iTXt chunk with the keyword "XML:com.adobe.xmp", embedding the UTF-8 XMP packet as read-only data protected by CRC checksums.[21] Document formats also integrate XMP seamlessly. PDF files embed XMP as a metadata stream in the document catalog (PDF 1.4 and later), stored as a UTF-8 encoded stream object for direct accessibility.[21] Encapsulated PostScript (EPS) files place the XMP packet as plain text between %%BeginMetadata:Implementation and Tools
Adobe XMP Toolkit
The Adobe XMP Toolkit is an official software development kit provided by Adobe for integrating Extensible Metadata Platform (XMP) functionality into applications, offering C++ and Java libraries to read, write, and manipulate XMP metadata since its initial availability in 2002.[26][27] The toolkit enables developers to embed and extract metadata directly within files, supporting the core XMP data model components such as RDF-based structures and namespaces for schema extension.[28] Key APIs in the toolkit include XMPCore, which handles parsing, manipulation, and serialization of XMP packets, and XMPFiles, which manages file input/output operations for locating, adding, and updating metadata across supported formats.[27] These APIs provide functions for packet creation, such as initializing RDF descriptions and serializing them into XML, as well as schema registration through namespace declarations to define custom properties.[28] Developers can use these to implement robust metadata workflows, including error handling for invalid RDF syntax and optimization for large-scale processing. The toolkit offers cross-platform support for Windows, macOS (formerly Macintosh), Linux (via UNIX compatibility), iOS, and Android, ensuring broad accessibility for desktop, mobile, and server-based applications.[27] It integrates seamlessly with Adobe Creative Cloud applications, such as Photoshop, where it powers metadata editing panels and automated tagging features.[3] As of the March 2025 release (version v2025.03), the toolkit maintains compatibility with evolving XMP standards, including security updates released in April 2025.[29]Third-Party and Open-Source Support
Several open-source libraries provide robust support for reading and writing XMP metadata, enabling integration into various applications and workflows. Exiv2, a C++ library for managing image metadata, offers full read/write capabilities for XMP in formats such as JPEG, TIFF, and PNG, including support for custom namespaces through its extensible API.[30] Similarly, ExifTool, a Perl-based command-line utility, delivers comprehensive XMP handling across numerous file types, with Python wrappers like PyExifTool facilitating programmatic access in scripting environments.[31] Adobe's XMP Toolkit SDK, available on GitHub, serves as an open-source reference implementation for XMP parsing and serialization, though it is primarily maintained by Adobe for broader ecosystem compatibility.[27] LibExif, focused on EXIF data, provides only partial XMP support, limited to basic extraction without full editing features.[32] In open-source image editing and management software, XMP adoption varies by tool. Darktable, a raw photo editor, implements full XMP read/write support using sidecar files to store edits and metadata, ensuring portability across workflows.[33] GIMP, through its integration with Exiv2, enables viewing and editing of standard XMP tags via the Metadata Editor plug-in, but offers partial support for complex custom schemas, which may require manual configuration or external tools for complete fidelity.[34] Challenges with custom schemas persist across these tools, as proprietary or niche XMP namespaces often demand additional schema definitions to avoid data loss during processing. Proprietary applications have incorporated XMP to enhance interoperability. Apple Photos on iOS and macOS supports importing and exporting XMP sidecar files alongside images, preserving metadata like keywords and ratings during transfers, though embedded XMP in files receives limited direct manipulation.[35] Microsoft Office, leveraging the Open XML format, allows embedding XMP as custom XML parts in documents such as Word and PowerPoint files, facilitating metadata exchange in enterprise environments. Digital asset management systems like Adobe Experience Manager have expanded XMP capabilities in 2025 updates, enabling automated metadata ingestion and schema customization for cloud-based asset workflows.[36] As of 2025, community efforts have boosted XMP accessibility in web technologies, with libraries like libxml2 compiled to WebAssembly enabling browser-based XMP parsing for client-side image processing without server dependencies.[37]Standards and Licensing
ISO Standardization Process
Adobe Systems Incorporated initiated the formal standardization process for the Extensible Metadata Platform (XMP) by submitting its specification to the International Organization for Standardization (ISO) Technical Committee 171, Subcommittee 2 (ISO/TC 171/SC 2) on document management and graphic technology. The submission was based on the Adobe XMP Specification Part 1 dated July 2010, leading to the publication of the first part of the standard in 2012.[38] The ISO 16684 series defines key aspects of XMP in a domain-neutral manner. ISO 16684-1:2012 (amended in 2019) establishes the foundational data model, XML-based serialization format, and core properties applicable across various resource types and file formats. Subsequent parts extend this framework: ISO 16684-2:2014 specifies the use of RELAX NG for describing and validating XMP schemas, enabling interoperable schema development; ISO 16684-3:2021 outlines serialization of the XMP data model to JSON-LD for enhanced web compatibility; and ISO 16684-4:2024 broadens XMP's application to describe semantic units (SU), such as user-defined content associated with one or more XMP packets, supporting extensions for digital assets and modular implementations.[6][39][40][41] Development of the standard involved collaboration with industry organizations, including the International Press Telecommunications Council (IPTC) since 2004 to integrate photo metadata schemas, and alignment with RDF/XML specifications to ensure compatibility with broader semantic web standards. These efforts facilitated the incorporation of domain-specific extensions, such as those for advertising identifiers through partnerships like Ad-ID in 2013.[42] The achievement of ISO standardization confers vendor-neutral status to XMP, decoupling it from proprietary origins and enabling broad interoperability across software ecosystems. This recognition also lends legal weight to XMP metadata in contractual agreements and regulatory contexts, promoting its use in professional workflows for content management and rights tracking.[42]Licensing and Compatibility
The Extensible Metadata Platform (XMP) specifications and toolkit are governed by permissive open-source licenses that facilitate broad adoption. The XMP specification, version 1.0, was publicly released by Adobe in 2005 under the XMP Specification Public Patent License, which provides royalty-free rights to implement the standard and allows commercial use without fees, subject to compliance with the license terms.[5] The XMP Toolkit SDK, a key implementation resource, was released under the BSD license on May 14, 2007, permitting modification, distribution, and commercial applications as long as the original copyright notice and disclaimer are preserved.[5] These licenses emphasize accessibility, with no royalties required for core XMP usage, though attribution to Adobe is mandated in derivative works.[27] Compatibility guidelines for XMP implementations focus on ensuring robust interoperability across readers and writers. Conforming XMP readers must process all recognized properties from standard schemas while ignoring unknown namespaces and properties to preserve extensibility, as outlined in the XMP data model based on RDF/XML principles.[12] Writers are required to generate well-formed XMP packets that adhere to XML serialization rules, embedding metadata without altering the host file's native structure or compatibility, particularly for formats like JPEG and PDF.[4] The ISO 16684-1 standard further specifies functional behaviors for conforming products, mandating that writers produce metadata compliant with the defined serialization format and that readers handle extensible elements gracefully to avoid errors in mixed-schema environments.[43] Backward compatibility is a core design principle in XMP evolution, ensuring ongoing support for legacy properties and schemas. Successive versions, including mappings from older formats like IPTC-IIM to XMP equivalents, maintain readability of historical metadata without requiring file modifications.[44] For instance, the XMP specification explicitly supports backward-compatible attributes in packet structures, such as optional XML declarations, to accommodate applications built against prior releases.[21] This approach allows seamless integration of pre-2005 metadata into modern workflows, with no deprecation of core properties across updates. Legally, the core XMP framework operates under Adobe's open licenses, enabling unrestricted use of standard schemas and properties in implementations worldwide. However, custom schemas—defined by third parties via unique namespace URIs—may impose intellectual property restrictions, such as proprietary licensing or usage limits, depending on the schema creator's terms, to protect specialized metadata extensions.[16] Developers must review schema documentation to ensure compliance, as the extensible nature of XMP permits such variations without affecting the base platform's openness.[45]History
Origins and Early Development
The Extensible Metadata Platform (XMP) originated within Adobe Systems in 2001 as a response to the growing fragmentation of metadata standards in creative software workflows. Prior to XMP, disparate formats such as EXIF for digital camera data, IPTC for photojournalism metadata, and Dublin Core for descriptive resource information operated in silos, complicating interoperability and extensibility across applications. Adobe aimed to unify these standards into a flexible framework that could embed rich, customizable metadata directly into files, enhancing asset management and collaboration in publishing and design environments.[46][47] A primary driver for XMP's development was the demand for extensible metadata capabilities in Adobe's flagship tools, particularly to support advanced features in Photoshop starting with version 7.0 (2002) and beyond, where traditional metadata handling proved insufficient for evolving creative needs. By integrating support for EXIF, IPTC, and Dublin Core, XMP enabled developers and users to extend schemas without proprietary lock-in, facilitating better digital rights management and workflow automation. Adobe selected the Resource Description Framework (RDF) as the underlying model to achieve this extensibility while aligning with W3C web standards.[47][9] Adobe formally announced XMP at the Seybold San Francisco conference in fall 2001, with its initial specification released that year alongside integration into Adobe Acrobat 5.0 and PDF 1.4. This debut focused on embedding metadata in PDF documents, marking XMP's entry as a labeling technology for content creation processes. In 2002, Adobe released the public XMP Toolkit SDK, an open-source API designed to encourage third-party adoption and broaden compatibility beyond Adobe's ecosystem.[9][47][8] Early development faced significant challenges due to the lack of overarching standardization in the metadata landscape, which often led to proprietary implementations that varied by software vendor and file format. These inconsistencies risked data loss during file conversions and limited cross-application usability, prompting Adobe to emphasize XMP's role in promoting a vendor-neutral approach from the outset. Despite these hurdles, the foundational specification laid the groundwork for XMP's evolution as a comprehensive platform.[47][46]Evolution and Key Milestones
In 2005, Adobe released the first public specification for XMP Part 1, detailing its data model and serialization formats, which marked a significant step toward broader industry adoption and laid the groundwork for formal standardization efforts.[46] This release emphasized XMP's role in enabling standardized metadata interchange across digital files, including initial support for embedding in formats like PDF and JPEG.[5] Between 2012 and 2016, the ISO 16684 series formalized XMP as an international standard, beginning with Part 1 in February 2012, which defined the core data model, serialization, and properties.[48] This was followed by Part 2 in 2014, specifying RELAX NG schemas for describing XMP structures, enhancing interoperability for complex metadata applications.[4] Concurrently, XMP integration deepened within Adobe Creative Cloud, launched in 2012, where it facilitated seamless metadata synchronization across tools like Photoshop and Illustrator, supporting collaborative workflows in creative production.[1] From 2019 to 2025, XMP evolved to better accommodate multimedia content through ISO extensions, including the 2019 revision of ISO 16684-1 for refined core properties, ISO 16684-3 (2021) for JSON-LD serialization, enabling richer semantic integration in dynamic media, and ISO 16684-4 (2024) for the use of XMP in describing semantic units within complex documents.[6] Adobe Experience Manager leverages XMP for cloud-based metadata management to automate asset lifecycles, extract embedded data from multimedia uploads, and streamline processing in digital asset repositories.[36] XMP saw widespread adoption in digital forensics for preserving chain-of-custody details and analyzing embedded timestamps in documents like PDFs, aiding investigations by maintaining metadata integrity during evidence handling.[49] In digital asset management (DAM) systems, it became a cornerstone for organizing large-scale media libraries, with tools extracting XMP schemas to tag and search assets efficiently.[50] Challenges with mobile formats were addressed through HEIC support, where applications now embed or generate XMP sidecars to retain metadata from iOS devices, ensuring compatibility without data loss.[51] Looking ahead, XMP's RDF foundation positions it for potential alignment with semantic web standards like Schema.org, facilitating enhanced discoverability of metadata in web contexts through shared vocabularies.[52]References
- https://wiki.creativecommons.org/wiki/XMP
