diff --git a/Resources/doc/usage.md b/Resources/doc/usage.md
index 2242ba1..05f6576 100644
--- a/Resources/doc/usage.md
+++ b/Resources/doc/usage.md
@@ -36,3 +36,28 @@ $exif = $reader->read('/path/to/file');
 
 echo 'Title: ' . $exif->getTitle() . PHP_EOL;
 ```
+
+### Google Motion Photos
+
+A Google Motion Photo is a JPEG with a short video appended to it. The reader
+reports the length of that video, in bytes counted from the end of the file,
+as `MicroVideoOffset`, whatever the adapter:
+
+```php
+<?php
+$reader = \PHPExif\Reader\Reader::factory(\PHPExif\Enum\ReaderType::NATIVE);
+$exif = $reader->read('/path/to/PXL_20261015_222940892.MP.jpg');
+
+$videoLength = $exif->getMicroVideoOffset(); // false if the file has no video
+```
+
+Both formats are supported: the legacy `GCamera:MicroVideoOffset` (Android 10
+and earlier) and Motion Photo 1.0 (`GCamera:MotionPhoto` with a
+`Container:Directory`, Android 11 and later, Ultra HDR files included). The
+XMP is read from the JPEG itself by `\PHPExif\MotionPhoto\MotionPhotoLocator`,
+which can also be used on its own:
+
+```php
+<?php
+$videoLength = \PHPExif\MotionPhoto\MotionPhotoLocator::locate('/path/to/file.jpg'); // 0 if none
+```
diff --git a/lib/PHPExif/MotionPhoto/FtypBox.php b/lib/PHPExif/MotionPhoto/FtypBox.php
new file mode 100644
index 0000000..d032085
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/FtypBox.php
@@ -0,0 +1,96 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+use function Safe\fread;
+use function Safe\unpack;
+
+/**
+ * Recognises the `ftyp` box that starts every MP4/QuickTime file:
+ *
+ *     [uint32 box size][ "ftyp" ][major brand ×4] …
+ *
+ * A match needs a plausible box size and a known video brand, so random
+ * bytes in JPEG image data are very unlikely to pass.
+ */
+final class FtypBox
+{
+    public const HEADER_LENGTH = 12;
+    public const CHUNK_SIZE = 65536;
+
+    private const TYPE = 'ftyp';
+    private const MIN_BOX_SIZE = 8;
+    private const MAX_BOX_SIZE = 256;
+    private const BRANDS = ['isom', 'iso2', 'iso4', 'iso5', 'iso6', 'mp41', 'mp42', 'avc1', 'qt  '];
+
+    /**
+     * @param resource $stream
+     */
+    public static function isAt($stream, int $offset): bool
+    {
+        fseek($stream, $offset);
+
+        return self::matches(fread($stream, self::HEADER_LENGTH), 0);
+    }
+
+    /**
+     * Finds the first `ftyp` box at or after `$from`, reading the stream in
+     * chunks so memory use does not depend on the file size.
+     *
+     * @param resource $stream
+     *
+     * @return int|null offset of the box in the stream
+     */
+    public static function scan($stream, int $from, int $fileSize): ?int
+    {
+        fseek($stream, $from);
+        $offset = $from;
+        $carry = '';
+        while ($offset < $fileSize) {
+            $chunk = fread($stream, self::CHUNK_SIZE);
+            if ($chunk === '') {
+                return null;
+            }
+
+            // The last bytes of the previous chunk are kept, so a box header
+            // across two chunks is still seen whole.
+            $buffer = $carry . $chunk;
+            $hit = self::firstMatch($buffer);
+            if ($hit !== null) {
+                return $offset - strlen($carry) + $hit;
+            }
+
+            $carry = substr($buffer, -(self::HEADER_LENGTH - 1));
+            $offset += strlen($chunk);
+        }
+
+        return null;
+    }
+
+    /**
+     * @return int|null position in `$buffer` of the first complete box header
+     */
+    private static function firstMatch(string $buffer): ?int
+    {
+        $typeAt = strpos($buffer, self::TYPE, 4);
+        while ($typeAt !== false && !self::matches($buffer, $typeAt - 4)) {
+            $typeAt = strpos($buffer, self::TYPE, $typeAt + 1);
+        }
+
+        return $typeAt === false ? null : $typeAt - 4;
+    }
+
+    private static function matches(string $bytes, int $at): bool
+    {
+        if (strlen($bytes) < $at + self::HEADER_LENGTH) {
+            return false;
+        }
+
+        $boxSize = unpack('N', $bytes, $at)[1];
+
+        return substr($bytes, $at + 4, 4) === self::TYPE &&
+            in_array(substr($bytes, $at + 8, 4), self::BRANDS, true) &&
+            $boxSize >= self::MIN_BOX_SIZE &&
+            $boxSize <= self::MAX_BOX_SIZE;
+    }
+}
diff --git a/lib/PHPExif/MotionPhoto/JpegHeader.php b/lib/PHPExif/MotionPhoto/JpegHeader.php
new file mode 100644
index 0000000..a363c78
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/JpegHeader.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+/**
+ * Result of {@see JpegXmpReader::read()}.
+ */
+final readonly class JpegHeader
+{
+    /**
+     * @param string|null $xmp               the first standard XMP packet, without its namespace prefix
+     * @param int         $imageDataOffset offset of the start-of-scan marker, i.e. where the header ends
+     */
+    public function __construct(
+        public ?string $xmp,
+        public int $imageDataOffset,
+    ) {
+    }
+}
diff --git a/lib/PHPExif/MotionPhoto/JpegImageEnd.php b/lib/PHPExif/MotionPhoto/JpegImageEnd.php
new file mode 100644
index 0000000..8cac060
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/JpegImageEnd.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+use function Safe\fread;
+
+/**
+ * Finds the end-of-image marker of a JPEG, so that what follows it (gain
+ * map, motion photo video) can be told apart from the compressed image data.
+ *
+ * Inside entropy-coded data every `0xFF` byte is followed by `0x00` (byte
+ * stuffing) or a restart marker, so the first `FF D9` after the start-of-scan
+ * marker is the end of the image.
+ */
+final class JpegImageEnd
+{
+    private const EOI = "\xFF\xD9";
+
+    /**
+     * @param resource $stream
+     * @param int      $from      offset of the start-of-scan marker
+     * @param int      $fileSize size of the file in bytes
+     *
+     * @return int|null offset just after the EOI marker; null if the image never ends
+     */
+    public static function find($stream, int $from, int $fileSize): ?int
+    {
+        fseek($stream, $from);
+        $offset = $from;
+        $carry = '';
+        while ($offset < $fileSize) {
+            $chunk = fread($stream, FtypBox::CHUNK_SIZE);
+            if ($chunk === '') {
+                return null;
+            }
+
+            // The last byte of the previous chunk is kept, so a marker split
+            // across two chunks is still seen whole.
+            $buffer = $carry . $chunk;
+            $eoiAt = strpos($buffer, self::EOI);
+            if ($eoiAt !== false) {
+                return $offset - strlen($carry) + $eoiAt + strlen(self::EOI);
+            }
+
+            $carry = substr($buffer, -1);
+            $offset += strlen($chunk);
+        }
+
+        return null;
+    }
+}
diff --git a/lib/PHPExif/MotionPhoto/JpegXmpReader.php b/lib/PHPExif/MotionPhoto/JpegXmpReader.php
new file mode 100644
index 0000000..b3f76f2
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/JpegXmpReader.php
@@ -0,0 +1,167 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+use function Safe\fread;
+use function Safe\unpack;
+
+/**
+ * Walks the marker segments of a JPEG header, from SOI to SOS, and picks the
+ * standard XMP packet.
+ *
+ * Only the header is read: the walk stops at the start-of-scan marker, so
+ * the entropy-coded image data and anything appended to the file (gain map,
+ * motion photo video) are never touched. Every segment length is checked
+ * against the file size before it is trusted.
+ */
+final class JpegXmpReader
+{
+    private const SOI = "\xFF\xD8";
+    private const MARKER_PREFIX = 0xFF;
+    private const SOS = 0xDA;
+    private const APP1 = 0xE1;
+    private const XMP_NAMESPACE = "http://ns.adobe.com/xap/1.0/\x00";
+
+    /**
+     * @param resource $stream    readable stream positioned at the start of the file
+     * @param int      $fileSize size of the file in bytes
+     *
+     * @return JpegHeader|null null if the stream is not a well-formed JPEG header
+     */
+    public static function read($stream, int $fileSize): ?JpegHeader
+    {
+        if (self::readBytes($stream, 2) !== self::SOI) {
+            return null;
+        }
+
+        $xmp = null;
+        while (true) {
+            $marker = self::readMarker($stream);
+            if ($marker === null) {
+                return null;
+            }
+            if ($marker === self::SOS) {
+                return new JpegHeader($xmp, self::position($stream) - 2);
+            }
+
+            $payloadLength = self::readPayloadLength($stream, $fileSize);
+            if ($payloadLength === null) {
+                return null;
+            }
+
+            $wantsXmp = $marker === self::APP1 && $xmp === null;
+            $payload = $wantsXmp ? self::readBytes($stream, $payloadLength) : self::skip($stream, $payloadLength);
+            $xmp = self::xmpOf($payload) ?? $xmp;
+        }
+    }
+
+    /**
+     * Reads the next marker code, skipping `0xFF` fill bytes.
+     *
+     * @param resource $stream
+     *
+     * @return int|null null at the end of the stream or if no marker prefix follows
+     */
+    private static function readMarker($stream): ?int
+    {
+        if (self::readByte($stream) !== self::MARKER_PREFIX) {
+            return null;
+        }
+
+        do {
+            $code = self::readByte($stream);
+        } while ($code === self::MARKER_PREFIX);
+
+        return $code;
+    }
+
+    /**
+     * Reads a segment length and returns the length of its payload.
+     *
+     * @param resource $stream
+     *
+     * @return int|null null if the length is invalid or the payload runs past the end of the file
+     */
+    private static function readPayloadLength($stream, int $fileSize): ?int
+    {
+        $bytes = self::readBytes($stream, 2);
+        if (strlen($bytes) !== 2) {
+            return null;
+        }
+
+        $segmentLength = unpack('n', $bytes)[1];
+        if (!is_int($segmentLength)) {
+            return null;
+        }
+
+        $payloadLength = $segmentLength - 2;
+        $isValid = $payloadLength >= 0 && self::position($stream) + $payloadLength <= $fileSize;
+
+        return $isValid ? $payloadLength : null;
+    }
+
+    /**
+     * Current offset in the stream.
+     *
+     * Not `Safe\ftell()`: Safe 2.x, still allowed by composer.json, has no
+     * wrapper for it.
+     *
+     * @param resource $stream
+     *
+     * @phpstan-impure
+     */
+    private static function position($stream): int
+    {
+        // @phpstan-ignore theCodingMachineSafe.function (no wrapper in Safe 2.x, false is handled here)
+        $position = \ftell($stream);
+        if ($position === false) {
+            throw new \RuntimeException('Cannot read the stream position');
+        }
+
+        return $position;
+    }
+
+    /**
+     * @return string|null the XMP packet if `$payload` is a standard XMP segment payload
+     */
+    private static function xmpOf(string $payload): ?string
+    {
+        return str_starts_with($payload, self::XMP_NAMESPACE) ? substr($payload, strlen(self::XMP_NAMESPACE)) : null;
+    }
+
+    /**
+     * @param resource $stream
+     *
+     * @phpstan-impure
+     */
+    private static function readByte($stream): ?int
+    {
+        $byte = self::readBytes($stream, 1);
+
+        return $byte === '' ? null : ord($byte);
+    }
+
+    /**
+     * @param resource $stream
+     *
+     * @return string fewer than `$length` bytes at the end of the stream
+     *
+     * @phpstan-impure
+     */
+    private static function readBytes($stream, int $length): string
+    {
+        return $length < 1 ? '' : fread($stream, $length);
+    }
+
+    /**
+     * @param resource $stream
+     *
+     * @return string always empty, so callers can treat a skipped payload like a read one
+     */
+    private static function skip($stream, int $length): string
+    {
+        fseek($stream, $length, SEEK_CUR);
+
+        return '';
+    }
+}
diff --git a/lib/PHPExif/MotionPhoto/MotionPhotoLocator.php b/lib/PHPExif/MotionPhoto/MotionPhotoLocator.php
new file mode 100644
index 0000000..1b6b87f
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/MotionPhotoLocator.php
@@ -0,0 +1,89 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+use function Safe\fclose;
+use function Safe\filesize;
+use function Safe\fopen;
+
+/**
+ * Finds the video embedded in a Google Motion Photo JPEG.
+ *
+ * In order:
+ *  1. the `Item:Length` of the container item with semantic `MotionPhoto`
+ *     (Motion Photo 1.0, Android 11+),
+ *  2. the legacy `GCamera:MicroVideoOffset` (Android ≤ 10),
+ *  3. if the file declares `GCamera:MotionPhoto="1"` but neither length
+ *     points at a video, the first MP4 `ftyp` box after the end of the
+ *     primary image.
+ *
+ * A declared length is only trusted if an `ftyp` box starts where it says.
+ * The XMP is read here rather than mapped from the adapters: exiftool
+ * flattens `Container:Directory` into parallel lists that no longer line up
+ * when an item has no `Item:Length` (the primary item of Pixel files), and
+ * the Native and ImageMagick adapters do not expose it at all.
+ */
+final class MotionPhotoLocator
+{
+    /**
+     * @param string $path path of the file
+     *
+     * @return int length of the video in bytes, counted from the end of the
+     *             file; `0` if there is none or the file cannot be read
+     */
+    public static function locate(string $path): int
+    {
+        if (!is_file($path) || !is_readable($path)) {
+            return 0;
+        }
+
+        $stream = fopen($path, 'rb');
+        try {
+            return self::locateInStream($stream, filesize($path));
+        } catch (\Throwable) {
+            return 0;
+        } finally {
+            fclose($stream);
+        }
+    }
+
+    /**
+     * @param resource $stream
+     */
+    private static function locateInStream($stream, int $fileSize): int
+    {
+        $header = JpegXmpReader::read($stream, $fileSize);
+        if ($header === null) {
+            return 0;
+        }
+
+        $xmp = MotionPhotoXmp::fromXml($header->xmp ?? '');
+        $declared = self::firstValidLength($stream, $fileSize, $header, [$xmp->itemLength, $xmp->legacyOffset]);
+        if ($declared !== 0 || !$xmp->isMotionPhoto) {
+            return $declared;
+        }
+
+        // Scan only after the primary image, so compressed image data that
+        // happens to look like an MP4 header cannot be taken for the video.
+        $imageEnd = JpegImageEnd::find($stream, $header->imageDataOffset, $fileSize);
+        $videoStart = $imageEnd === null ? null : FtypBox::scan($stream, $imageEnd, $fileSize);
+
+        return $videoStart === null ? 0 : $fileSize - $videoStart;
+    }
+
+    /**
+     * @param resource $stream
+     * @param int[]    $lengths candidate video lengths, `0` meaning "not declared"
+     */
+    private static function firstValidLength($stream, int $fileSize, JpegHeader $header, array $lengths): int
+    {
+        foreach ($lengths as $length) {
+            $isAfterHeader = $length > 0 && $length <= $fileSize - $header->imageDataOffset;
+            if ($isAfterHeader && FtypBox::isAt($stream, $fileSize - $length)) {
+                return $length;
+            }
+        }
+
+        return 0;
+    }
+}
diff --git a/lib/PHPExif/MotionPhoto/MotionPhotoXmp.php b/lib/PHPExif/MotionPhoto/MotionPhotoXmp.php
new file mode 100644
index 0000000..226872b
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/MotionPhotoXmp.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+/**
+ * What the XMP packet of a JPEG says about an embedded motion photo video
+ *.
+ *
+ * Both lengths count bytes from the end of the file; `0` means "not
+ * declared". Nothing here is validated against the file: that is the job of
+ * {@see MotionPhotoLocator}.
+ */
+final readonly class MotionPhotoXmp
+{
+    public const NS_CAMERA = 'http://ns.google.com/photos/1.0/camera/';
+    public const NS_CONTAINER = 'http://ns.google.com/photos/1.0/container/';
+    public const NS_ITEM = 'http://ns.google.com/photos/1.0/container/item/';
+
+    /**
+     * @param bool $isMotionPhoto `GCamera:MotionPhoto` is `1` (Motion Photo 1.0)
+     * @param int  $itemLength     `Item:Length` of the container item with semantic `MotionPhoto`
+     * @param int  $legacyOffset   `GCamera:MicroVideoOffset` (Android ≤ 10)
+     */
+    public function __construct(
+        public bool $isMotionPhoto,
+        public int $itemLength,
+        public int $legacyOffset,
+    ) {
+    }
+
+    public static function none(): self
+    {
+        return new self(false, 0, 0);
+    }
+
+    /**
+     * Parses an XMP packet; malformed or unrelated XML yields {@see none()}.
+     *
+     * The SAX parser of `ext-xml` does not load external entities, so the
+     * untrusted packet cannot pull in other files.
+     */
+    public static function fromXml(string $xml): self
+    {
+        $handler = new MotionPhotoXmpHandler();
+        $parser = xml_parser_create_ns('UTF-8', MotionPhotoXmpHandler::SEPARATOR);
+        // Not Safe: it only wraps this function for PHP 8.4, and setting a valid option cannot fail.
+        // @phpstan-ignore theCodingMachineSafe.function
+        \xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
+        xml_set_element_handler($parser, $handler->start(...), $handler->end(...));
+        xml_set_character_data_handler($parser, $handler->text(...));
+
+        $isWellFormed = xml_parse($parser, $xml, true) === 1;
+
+        return $isWellFormed ? $handler->result() : self::none();
+    }
+}
diff --git a/lib/PHPExif/MotionPhoto/MotionPhotoXmpHandler.php b/lib/PHPExif/MotionPhoto/MotionPhotoXmpHandler.php
new file mode 100644
index 0000000..e24c5eb
--- /dev/null
+++ b/lib/PHPExif/MotionPhoto/MotionPhotoXmpHandler.php
@@ -0,0 +1,104 @@
+<?php
+
+namespace PHPExif\MotionPhoto;
+
+/**
+ * SAX callbacks behind {@see MotionPhotoXmp::fromXml()}.
+ *
+ * XMP allows a property both as an attribute and as a child element, so each
+ * property is read from either form:
+ *
+ *     <rdf:Description GCamera:MotionPhoto="1">
+ *     <GCamera:MotionPhoto>1</GCamera:MotionPhoto>
+ *
+ * Names arrive as `<namespace URI>|<local name>`, so prefixes do not matter.
+ *
+ * @internal
+ */
+final class MotionPhotoXmpHandler
+{
+    public const SEPARATOR = '|';
+
+    private const MOTION_PHOTO = MotionPhotoXmp::NS_CAMERA . self::SEPARATOR . 'MotionPhoto';
+    private const MICRO_VIDEO_OFFSET = MotionPhotoXmp::NS_CAMERA . self::SEPARATOR . 'MicroVideoOffset';
+    private const CONTAINER_ITEM = MotionPhotoXmp::NS_CONTAINER . self::SEPARATOR . 'Item';
+    private const ITEM_SEMANTIC = MotionPhotoXmp::NS_ITEM . self::SEPARATOR . 'Semantic';
+    private const ITEM_LENGTH = MotionPhotoXmp::NS_ITEM . self::SEPARATOR . 'Length';
+    private const SEMANTIC_MOTION_PHOTO = 'MotionPhoto';
+    private const CAMERA_PROPERTIES = [self::MOTION_PHOTO => true, self::MICRO_VIDEO_OFFSET => true];
+    private const ITEM_PROPERTIES = [self::ITEM_SEMANTIC => true, self::ITEM_LENGTH => true];
+
+    /** @var array<string,string> raw values by qualified name: the two camera properties */
+    private array $camera = [];
+
+    /** @var array<string,string>|null raw `Item:*` values of the container item being read */
+    private ?array $item = null;
+
+    private ?string $videoItemLength = null;
+
+    /** qualified name of the element whose text is being collected */
+    private ?string $textOf = null;
+    private string $text = '';
+
+    /**
+     * @param array<string,string> $attributes
+     */
+    public function start(\XMLParser $parser, string $name, array $attributes): void
+    {
+        $this->camera += array_intersect_key($attributes, self::CAMERA_PROPERTIES);
+        $this->item = $name === self::CONTAINER_ITEM
+            ? array_intersect_key($attributes, self::ITEM_PROPERTIES)
+            : $this->item;
+        $this->textOf = $name;
+        $this->text = '';
+    }
+
+    public function text(\XMLParser $parser, string $data): void
+    {
+        $this->text .= $data;
+    }
+
+    public function end(\XMLParser $parser, string $name): void
+    {
+        $value = trim($this->text);
+        $isTextElement = $this->textOf === $name;
+        $this->textOf = null;
+        $this->text = '';
+
+        if ($isTextElement && in_array($name, [self::MOTION_PHOTO, self::MICRO_VIDEO_OFFSET], true)) {
+            $this->camera[$name] ??= $value;
+        }
+        if ($isTextElement && $this->item !== null && in_array($name, [self::ITEM_SEMANTIC, self::ITEM_LENGTH], true)) {
+            $this->item[$name] ??= $value;
+        }
+        if ($name === self::CONTAINER_ITEM) {
+            $this->closeItem();
+        }
+    }
+
+    public function result(): MotionPhotoXmp
+    {
+        return new MotionPhotoXmp(
+            isMotionPhoto: trim($this->camera[self::MOTION_PHOTO] ?? '') === '1',
+            itemLength: self::toLength($this->videoItemLength),
+            legacyOffset: self::toLength($this->camera[self::MICRO_VIDEO_OFFSET] ?? null),
+        );
+    }
+
+    private function closeItem(): void
+    {
+        $isVideo = ($this->item[self::ITEM_SEMANTIC] ?? null) === self::SEMANTIC_MOTION_PHOTO;
+        $this->videoItemLength ??= $isVideo ? ($this->item[self::ITEM_LENGTH] ?? null) : null;
+        $this->item = null;
+    }
+
+    /**
+     * @return int the value if it is a plain non-negative decimal integer, `0` otherwise
+     */
+    private static function toLength(?string $raw): int
+    {
+        $value = trim($raw ?? '');
+
+        return ctype_digit($value) ? (int) $value : 0;
+    }
+}
diff --git a/lib/PHPExif/Reader/Reader.php b/lib/PHPExif/Reader/Reader.php
index 27d8a82..93ce94e 100644
--- a/lib/PHPExif/Reader/Reader.php
+++ b/lib/PHPExif/Reader/Reader.php
@@ -10,6 +10,7 @@
 use PHPExif\Contracts\ReaderInterface;
 use PHPExif\Exif;
 use PHPExif\Enum\ReaderType;
+use PHPExif\MotionPhoto\MotionPhotoLocator;
 
 /**
  * PHP Exif Reader
@@ -52,12 +53,23 @@ public static function factory(ReaderType $type, string $path = ''): Reader
     /**
      * Reads & parses the EXIF data from given file
      *
+     * When the adapter reports no `MicroVideoOffset`, the video of a Google
+     * Motion Photo (legacy or Motion Photo 1.0 format) is located from the
+     * file itself, so every adapter reports it the same way.
+     *
      * @param string $file
      * @return Exif Instance of Exif object with data
      * @throws PhpExifReaderException If the EXIF data could not be read
      */
     public function read(string $file): Exif
     {
-        return $this->adapter->getExifFromFile($file);
+        $exif = $this->adapter->getExifFromFile($file);
+        if ($exif->getMicroVideoOffset() !== false) {
+            return $exif;
+        }
+
+        $videoLength = MotionPhotoLocator::locate($file);
+
+        return $videoLength > 0 ? $exif->setMicroVideoOffset((string) $videoLength) : $exif;
     }
 }
diff --git a/tests/PHPExif/MotionPhoto/JpegXmpReaderTest.php b/tests/PHPExif/MotionPhoto/JpegXmpReaderTest.php
new file mode 100644
index 0000000..a615658
--- /dev/null
+++ b/tests/PHPExif/MotionPhoto/JpegXmpReaderTest.php
@@ -0,0 +1,147 @@
+<?php
+
+use PHPExif\MotionPhoto\JpegHeader;
+use PHPExif\MotionPhoto\JpegXmpReader;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Covers the JPEG marker walk that finds the standard XMP packet
+ * and the start of the image data.
+ */
+class JpegXmpReaderTest extends TestCase
+{
+    private const SOI = "\xFF\xD8";
+    private const XMP_NAMESPACE = "http://ns.adobe.com/xap/1.0/\x00";
+    private const EXTENDED_XMP_NAMESPACE = "http://ns.adobe.com/xmp/extension/\x00";
+    private const XMP = '<x:xmpmeta xmlns:x="adobe:ns:meta/"/>';
+
+    #[Group('motionphoto')]
+    public function testReturnsXmpAndImageDataOffset(): void
+    {
+        $head = self::SOI .
+            self::segment(0xE0, "JFIF\x00\x01\x01") .
+            self::segment(0xE1, "Exif\x00\x00II*\x00") .
+            self::segment(0xE1, self::XMP_NAMESPACE . self::XMP) .
+            self::segment(0xDB, str_repeat("\x01", 65));
+        $header = $this->read($head . self::scan());
+
+        self::assertInstanceOf(JpegHeader::class, $header);
+        self::assertSame(self::XMP, $header->xmp);
+        self::assertSame(strlen($head), $header->imageDataOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testXmpIsNullWithoutXmpSegment(): void
+    {
+        $head = self::SOI . self::segment(0xE1, "Exif\x00\x00II*\x00");
+        $header = $this->read($head . self::scan());
+
+        self::assertInstanceOf(JpegHeader::class, $header);
+        self::assertNull($header->xmp);
+        self::assertSame(strlen($head), $header->imageDataOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testExtendedXmpIsNotTheStandardPacket(): void
+    {
+        $header = $this->read(self::SOI . self::segment(0xE1, self::EXTENDED_XMP_NAMESPACE . self::XMP) . self::scan());
+
+        self::assertNull($header?->xmp);
+    }
+
+    #[Group('motionphoto')]
+    public function testFirstStandardPacketWins(): void
+    {
+        $header = $this->read(self::SOI .
+            self::segment(0xE1, self::XMP_NAMESPACE . self::XMP) .
+            self::segment(0xE1, self::XMP_NAMESPACE . '<second/>') .
+            self::scan());
+
+        self::assertSame(self::XMP, $header?->xmp);
+    }
+
+    #[Group('motionphoto')]
+    public function testFillBytesBeforeAMarkerAreSkipped(): void
+    {
+        $header = $this->read(self::SOI . "\xFF\xFF" . self::segment(0xE1, self::XMP_NAMESPACE . self::XMP) . self::scan());
+
+        self::assertSame(self::XMP, $header?->xmp);
+    }
+
+    #[Group('motionphoto')]
+    public function testSegmentsAfterTheImageDataAreNotRead(): void
+    {
+        $header = $this->read(self::SOI . self::scan() . self::segment(0xE1, self::XMP_NAMESPACE . self::XMP));
+
+        self::assertNull($header?->xmp);
+        self::assertSame(2, $header?->imageDataOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testNotAJpeg(): void
+    {
+        self::assertNull($this->read("\x89PNG\r\n\x1A\n" . str_repeat("\x00", 32)));
+    }
+
+    #[Group('motionphoto')]
+    public function testEmptyStream(): void
+    {
+        self::assertNull($this->read(''));
+    }
+
+    #[Group('motionphoto')]
+    public function testTruncatedMarker(): void
+    {
+        self::assertNull($this->read(self::SOI . "\xFF\xE1\x00"));
+    }
+
+    #[Group('motionphoto')]
+    public function testMissingImageData(): void
+    {
+        self::assertNull($this->read(self::SOI . self::segment(0xE1, self::XMP_NAMESPACE . self::XMP)));
+    }
+
+    #[Group('motionphoto')]
+    public function testSegmentLengthBeyondTheFile(): void
+    {
+        self::assertNull($this->read(self::SOI . "\xFF\xE1\x40\x00" . self::XMP_NAMESPACE . self::XMP));
+    }
+
+    #[Group('motionphoto')]
+    public function testSegmentLengthBelowTwo(): void
+    {
+        self::assertNull($this->read(self::SOI . "\xFF\xE1\x00\x01" . self::scan()));
+    }
+
+    #[Group('motionphoto')]
+    public function testMarkerWithoutFfPrefix(): void
+    {
+        self::assertNull($this->read(self::SOI . "\x00\xE1\x00\x04ab" . self::scan()));
+    }
+
+    private function read(string $bytes): ?JpegHeader
+    {
+        $stream = fopen('php://memory', 'r+b');
+        fwrite($stream, $bytes);
+        rewind($stream);
+        try {
+            return JpegXmpReader::read($stream, strlen($bytes));
+        } finally {
+            fclose($stream);
+        }
+    }
+
+    private static function segment(int $marker, string $payload): string
+    {
+        return "\xFF" . chr($marker) . pack('n', strlen($payload) + 2) . $payload;
+    }
+
+    /**
+     * A start-of-scan segment followed by some entropy-coded bytes and EOI.
+     */
+    private static function scan(): string
+    {
+        return self::segment(0xDA, "\x01\x01\x00\x00\x3F\x00") . "\x12\x34\x56\x78\xFF\xD9";
+    }
+}
diff --git a/tests/PHPExif/MotionPhoto/MotionPhotoLocatorTest.php b/tests/PHPExif/MotionPhoto/MotionPhotoLocatorTest.php
new file mode 100644
index 0000000..c099444
--- /dev/null
+++ b/tests/PHPExif/MotionPhoto/MotionPhotoLocatorTest.php
@@ -0,0 +1,239 @@
+<?php
+
+use PHPExif\MotionPhoto\MotionPhotoLocator;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Covers locating the video of a motion photo: declared lengths checked
+ * against an MP4 `ftyp` box, and the scan after the primary image.
+ */
+class MotionPhotoLocatorTest extends TestCase
+{
+    private const CHUNK_SIZE = 65536;
+
+    /** @var string[] */
+    private array $files = [];
+
+    protected function tearDown(): void
+    {
+        array_map(fn (string $path) => @unlink($path), $this->files);
+        parent::tearDown();
+    }
+
+    #[Group('motionphoto')]
+    public function testDeclaredItemLength(): void
+    {
+        $video = self::mp4(5000);
+        $file = $this->file(self::jpeg(self::motionPhoto(strlen($video))) . $video);
+
+        self::assertSame(5000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testUltraHdrLayoutSkipsTheGainMap(): void
+    {
+        $video = self::mp4(5000);
+        $gainMap = self::jpeg('');
+        $file = $this->file(self::jpeg(self::motionPhoto(strlen($video))) . $gainMap . $video);
+
+        self::assertSame(5000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testDeclaredLegacyOffset(): void
+    {
+        $video = self::mp4(3000);
+        $file = $this->file(self::jpeg('GCamera:MicroVideo="1" GCamera:MicroVideoOffset="3000"') . $video);
+
+        self::assertSame(3000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testWrongDeclaredLengthFallsBackToTheScan(): void
+    {
+        $video = self::mp4(5000);
+        $file = $this->file(self::jpeg(self::motionPhoto(5007)) . $video);
+
+        self::assertSame(5000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testWrongLegacyOffsetIsNotScanned(): void
+    {
+        $video = self::mp4(3000);
+        $file = $this->file(self::jpeg('GCamera:MicroVideo="1" GCamera:MicroVideoOffset="3333"') . $video);
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testMissingVideoItemIsScanned(): void
+    {
+        $video = self::mp4(4000);
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"') . $video);
+
+        self::assertSame(4000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanMiss(): void
+    {
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"') . str_repeat("\x00", 4000));
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanRejectsUnknownBrands(): void
+    {
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"') . self::mp4(4000, 'heic'));
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanRejectsImplausibleBoxSizes(): void
+    {
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"') . self::mp4(4000, 'isom', 4096));
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanFindsABoxAcrossAChunkBoundary(): void
+    {
+        $video = self::mp4(4000);
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"') . str_repeat("\x00", self::CHUNK_SIZE - 6) . $video);
+
+        self::assertSame(4000, MotionPhotoLocator::locate($file));
+    }
+
+    /**
+     *: compressed image data may contain bytes that look like
+     * an MP4 header; the scan starts after the primary image's EOI marker.
+     */
+    #[Group('motionphoto')]
+    public function testScanSkipsTheImageDataOfThePrimaryImage(): void
+    {
+        $lookAlike = self::mp4(24);
+        $video = self::mp4(4000);
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"', 200, $lookAlike . "\x12\x12") . $video);
+
+        self::assertSame(4000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanFindsAnEoiAcrossAChunkBoundary(): void
+    {
+        $video = self::mp4(4000);
+        // SOS at offset 0 of the image data: FF at 65535, D9 at 65536.
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"', self::CHUNK_SIZE + 1) . $video);
+
+        self::assertSame(4000, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanNeedsTheEndOfThePrimaryImage(): void
+    {
+        $truncated = substr(self::jpeg('GCamera:MotionPhoto="1"'), 0, -2);
+        $file = $this->file($truncated . self::mp4(4000));
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testPlainJpegWithTrailingVideoIsNotAMotionPhoto(): void
+    {
+        $file = $this->file(self::jpeg('') . self::mp4(4000));
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testLengthOfTheWholeFileIsRejected(): void
+    {
+        $video = self::mp4(4000);
+        $bytes = self::jpeg(self::motionPhoto(999999)) . $video;
+        $file = $this->file($bytes);
+
+        self::assertSame(4000, MotionPhotoLocator::locate($file), 'falls back to the scan');
+    }
+
+    #[Group('motionphoto')]
+    public function testNotAJpeg(): void
+    {
+        $file = $this->file(self::mp4(4000));
+
+        self::assertSame(0, MotionPhotoLocator::locate($file));
+    }
+
+    #[Group('motionphoto')]
+    public function testUnreadableFileReturnsZero(): void
+    {
+        self::assertSame(0, MotionPhotoLocator::locate('/nonexistent/' . uniqid() . '.jpg'));
+    }
+
+    #[Group('motionphoto')]
+    public function testSyntheticSamples(): void
+    {
+        self::assertSame(10705, MotionPhotoLocator::locate(PHPEXIF_TEST_ROOT . '/files/motion_photo_v1.jpg'));
+        self::assertSame(10705, MotionPhotoLocator::locate(PHPEXIF_TEST_ROOT . '/files/motion_photo_ultrahdr.jpg'));
+    }
+
+    #[Group('motionphoto')]
+    public function testScanUsesConstantMemory(): void
+    {
+        $video = self::mp4(4000);
+        $file = $this->file(self::jpeg('GCamera:MotionPhoto="1"', 20 * 1024 * 1024) . $video);
+        gc_collect_cycles();
+        memory_reset_peak_usage();
+        $before = memory_get_usage();
+
+        self::assertSame(4000, MotionPhotoLocator::locate($file));
+        self::assertLessThan(2 * 1024 * 1024, memory_get_peak_usage() - $before);
+    }
+
+    private function file(string $bytes): string
+    {
+        $path = tempnam(sys_get_temp_dir(), 'phpexif-mp-');
+        $this->files[] = $path;
+        file_put_contents($path, $bytes);
+
+        return $path;
+    }
+
+    private static function motionPhoto(int $videoLength): string
+    {
+        return 'GCamera:MotionPhoto="1">' .
+            '<Container:Directory><rdf:Seq>' .
+            '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary"/></rdf:li>' .
+            '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="' . $videoLength . '"/></rdf:li>' .
+            '</rdf:Seq></Container:Directory></rdf:Description><rdf:Description';
+    }
+
+    /**
+     * A JPEG whose XMP carries `$camera` (attributes, optionally closing the
+     * description early to add a container directory), and whose image data
+     * spans `$imageBytes` bytes from the SOS marker to the end of EOI, ending
+     * with `$imageData`.
+     */
+    private static function jpeg(string $camera, int $imageBytes = 64, string $imageData = ''): string
+    {
+        $xmp = $camera === '' ? '' : "http://ns.adobe.com/xap/1.0/\x00" .
+            '<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' .
+            '<rdf:Description xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" xmlns:Container="http://ns.google.com/photos/1.0/container/" xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' .
+            $camera . '/></rdf:RDF></x:xmpmeta>';
+        $app1 = $xmp === '' ? '' : "\xFF\xE1" . pack('n', strlen($xmp) + 2) . $xmp;
+        $sos = "\xFF\xDA\x00\x08\x01\x01\x00\x00\x3F\x00";
+
+        return "\xFF\xD8" . $app1 . $sos . str_repeat("\x12", $imageBytes - 12 - strlen($imageData)) . $imageData . "\xFF\xD9";
+    }
+
+    private static function mp4(int $length, string $brand = 'isom', int $boxSize = 24): string
+    {
+        $ftyp = pack('N', $boxSize) . 'ftyp' . $brand . "\x00\x00\x02\x00" . 'isommp41';
+
+        return $ftyp . str_repeat("\x00", $length - strlen($ftyp));
+    }
+}
diff --git a/tests/PHPExif/MotionPhoto/MotionPhotoXmpTest.php b/tests/PHPExif/MotionPhoto/MotionPhotoXmpTest.php
new file mode 100644
index 0000000..6896aa7
--- /dev/null
+++ b/tests/PHPExif/MotionPhoto/MotionPhotoXmpTest.php
@@ -0,0 +1,251 @@
+<?php
+
+use PHPExif\MotionPhoto\MotionPhotoXmp;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Covers reading the Google camera and container XMP of motion
+ * photos.
+ */
+class MotionPhotoXmpTest extends TestCase
+{
+    /**
+     * The standard XMP packet of a Pixel 11 Pro Ultra HDR motion photo
+     * verbatim except for the maker note, which was stripped.
+     */
+    private const PIXEL_XMP = <<<'XML'
+        <x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">
+          <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+            <rdf:Description rdf:about=""
+                xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/"
+                xmlns:GCamera="http://ns.google.com/photos/1.0/camera/"
+                xmlns:Container="http://ns.google.com/photos/1.0/container/"
+                xmlns:Item="http://ns.google.com/photos/1.0/container/item/"
+              hdrgm:Version="1.0"
+              GCamera:GFileMetadata="SgQIABAB"
+              GCamera:MotionPhoto="1"
+              GCamera:MotionPhotoVersion="1"
+              GCamera:MotionPhotoPresentationTimestampUs="1166896">
+              <Container:Directory>
+                <rdf:Seq>
+                  <rdf:li rdf:parseType="Resource">
+                    <Container:Item
+                      Item:Mime="image/jpeg"
+                      Item:Semantic="Primary"/>
+                  </rdf:li>
+                  <rdf:li rdf:parseType="Resource">
+                    <Container:Item
+                      Item:Length="1753"
+                      Item:Mime="image/jpeg"
+                      Item:Semantic="GainMap"/>
+                  </rdf:li>
+                  <rdf:li rdf:parseType="Resource">
+                    <Container:Item
+                      Item:Mime="video/mp4"
+                      Item:Semantic="MotionPhoto"
+                      Item:Length="3725212"
+                      Item:Padding="0"/>
+                  </rdf:li>
+                </rdf:Seq>
+              </Container:Directory>
+            </rdf:Description>
+          </rdf:RDF>
+        </x:xmpmeta>
+        XML;
+
+    #[Group('motionphoto')]
+    public function testPixelUltraHdrMotionPhoto(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::PIXEL_XMP);
+
+        self::assertTrue($xmp->isMotionPhoto);
+        self::assertSame(3725212, $xmp->itemLength);
+        self::assertSame(0, $xmp->legacyOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testMotionPhotoWithoutGainMap(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::motionPhoto(
+            self::item('Primary') . self::item('MotionPhoto', 'Item:Length="10705" Item:Padding="0"')
+        ));
+
+        self::assertTrue($xmp->isMotionPhoto);
+        self::assertSame(10705, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testLengthBeforeSemantic(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::motionPhoto('<rdf:li rdf:parseType="Resource"><Container:Item Item:Length="42" Item:Semantic="MotionPhoto"/></rdf:li>'));
+
+        self::assertSame(42, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testMotionPhotoFlagWithoutVideoItem(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::motionPhoto(self::item('Primary')));
+
+        self::assertTrue($xmp->isMotionPhoto);
+        self::assertSame(0, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testMotionPhotoFlagWithoutDirectory(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::description('GCamera:MotionPhoto="1"', ''));
+
+        self::assertTrue($xmp->isMotionPhoto);
+        self::assertSame(0, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testVideoItemWithoutLength(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::motionPhoto(self::item('Primary') . self::item('MotionPhoto')));
+
+        self::assertSame(0, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testOnlyTheMotionPhotoItemLengthCounts(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::motionPhoto(self::item('GainMap', 'Item:Length="1753"')));
+
+        self::assertSame(0, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testLegacyMicroVideo(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::description('GCamera:MicroVideo="1" GCamera:MicroVideoVersion="1" GCamera:MicroVideoOffset="4495341" GCamera:MicroVideoPresentationTimestampUs="1366016"', ''));
+
+        self::assertFalse($xmp->isMotionPhoto);
+        self::assertSame(0, $xmp->itemLength);
+        self::assertSame(4495341, $xmp->legacyOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testElementSyntax(): void
+    {
+        $body = '<GCamera:MotionPhoto>1</GCamera:MotionPhoto>' .
+            '<Container:Directory><rdf:Seq><rdf:li rdf:parseType="Resource"><Container:Item>' .
+            '<Item:Semantic>MotionPhoto</Item:Semantic><Item:Length> 777 </Item:Length>' .
+            '</Container:Item></rdf:li></rdf:Seq></Container:Directory>';
+        $xmp = MotionPhotoXmp::fromXml(self::description('', $body));
+
+        self::assertTrue($xmp->isMotionPhoto);
+        self::assertSame(777, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testLegacyOffsetElementSyntax(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::description('', '<GCamera:MicroVideoOffset>1234</GCamera:MicroVideoOffset>'));
+
+        self::assertSame(1234, $xmp->legacyOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testNamespaceIsMatchedByUriNotPrefix(): void
+    {
+        $xml = '<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' .
+            '<rdf:Description xmlns:Cam="http://ns.google.com/photos/1.0/camera/" xmlns:C="http://ns.google.com/photos/1.0/container/" xmlns:I="http://ns.google.com/photos/1.0/container/item/" Cam:MotionPhoto="1">' .
+            '<C:Directory><rdf:Seq><rdf:li rdf:parseType="Resource"><C:Item I:Semantic="MotionPhoto" I:Length="99"/></rdf:li></rdf:Seq></C:Directory>' .
+            '</rdf:Description></rdf:RDF></x:xmpmeta>';
+        $xmp = MotionPhotoXmp::fromXml($xml);
+
+        self::assertTrue($xmp->isMotionPhoto);
+        self::assertSame(99, $xmp->itemLength);
+    }
+
+    #[Group('motionphoto')]
+    public function testWrongNamespaceIsIgnored(): void
+    {
+        $xml = '<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' .
+            '<rdf:Description xmlns:GCamera="http://example.com/not-google/" GCamera:MotionPhoto="1" GCamera:MicroVideoOffset="10"/>' .
+            '</rdf:RDF></x:xmpmeta>';
+
+        self::assertNone(MotionPhotoXmp::fromXml($xml));
+    }
+
+    #[Group('motionphoto')]
+    public function testMotionPhotoFlagMustBeOne(): void
+    {
+        self::assertFalse(MotionPhotoXmp::fromXml(self::description('GCamera:MotionPhoto="0"', ''))->isMotionPhoto);
+    }
+
+    #[Group('motionphoto')]
+    public function testInvalidNumbersReadAsZero(): void
+    {
+        $xmp = MotionPhotoXmp::fromXml(self::description(
+            'GCamera:MotionPhoto="1" GCamera:MicroVideoOffset="-5"',
+            '<Container:Directory><rdf:Seq>' . self::item('MotionPhoto', 'Item:Length="12abc"') . '</rdf:Seq></Container:Directory>'
+        ));
+
+        self::assertSame(0, $xmp->itemLength);
+        self::assertSame(0, $xmp->legacyOffset);
+    }
+
+    #[Group('motionphoto')]
+    public function testUnrelatedXmp(): void
+    {
+        $xml = '<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' .
+            '<rdf:Description xmlns:dc="http://purl.org/dc/elements/1.1/"><dc:subject><rdf:Bag><rdf:li>Mongolia</rdf:li></rdf:Bag></dc:subject></rdf:Description>' .
+            '</rdf:RDF></x:xmpmeta>';
+
+        self::assertNone(MotionPhotoXmp::fromXml($xml));
+    }
+
+    #[Group('motionphoto')]
+    public function testMalformedXml(): void
+    {
+        self::assertNone(MotionPhotoXmp::fromXml(substr(self::PIXEL_XMP, 0, 900)));
+    }
+
+    #[Group('motionphoto')]
+    public function testEmptyString(): void
+    {
+        self::assertNone(MotionPhotoXmp::fromXml(''));
+    }
+
+    #[Group('motionphoto')]
+    public function testExternalEntitiesAreNotResolved(): void
+    {
+        $xml = '<?xml version="1.0"?><!DOCTYPE x [<!ENTITY ext SYSTEM "file:///etc/hosts">]>' .
+            '<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' .
+            '<rdf:Description xmlns:GCamera="http://ns.google.com/photos/1.0/camera/"><GCamera:MicroVideoOffset>&ext;</GCamera:MicroVideoOffset></rdf:Description>' .
+            '</rdf:RDF></x:xmpmeta>';
+
+        self::assertSame(0, MotionPhotoXmp::fromXml($xml)->legacyOffset);
+    }
+
+    private static function assertNone(MotionPhotoXmp $xmp): void
+    {
+        self::assertFalse($xmp->isMotionPhoto);
+        self::assertSame(0, $xmp->itemLength);
+        self::assertSame(0, $xmp->legacyOffset);
+    }
+
+    private static function item(string $semantic, string $extra = ''): string
+    {
+        return '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="x/y" Item:Semantic="' . $semantic . '" ' . $extra . '/></rdf:li>';
+    }
+
+    private static function motionPhoto(string $items): string
+    {
+        return self::description('GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1"', '<Container:Directory><rdf:Seq>' . $items . '</rdf:Seq></Container:Directory>');
+    }
+
+    private static function description(string $attributes, string $body): string
+    {
+        return '<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:GCamera="http://ns.google.com/photos/1.0/camera/"' .
+            ' xmlns:Container="http://ns.google.com/photos/1.0/container/"' .
+            ' xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' .
+            $attributes . '>' . $body . '</rdf:Description></rdf:RDF></x:xmpmeta>';
+    }
+}
diff --git a/tests/PHPExif/MotionPhoto/ReaderMotionPhotoTest.php b/tests/PHPExif/MotionPhoto/ReaderMotionPhotoTest.php
new file mode 100644
index 0000000..7af0e16
--- /dev/null
+++ b/tests/PHPExif/MotionPhoto/ReaderMotionPhotoTest.php
@@ -0,0 +1,85 @@
+<?php
+
+use PHPExif\Adapter\Exiftool;
+use PHPExif\Adapter\ImageMagick;
+use PHPExif\Adapter\Native;
+use PHPExif\Contracts\AdapterInterface;
+use PHPExif\Exif;
+use PHPExif\Reader\Reader;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Group;
+use PHPUnit\Framework\TestCase;
+
+/**
+ * The reader reports the video of a Google Motion Photo as
+ * `MicroVideoOffset` (its length in bytes from the end of the file) for
+ * every adapter, in the legacy and in the Motion Photo 1.0 format.
+ */
+class ReaderMotionPhotoTest extends TestCase
+{
+    /**
+     * Length of the video appended to both sample files.
+     */
+    private const VIDEO_LENGTH = '10705';
+
+    /**
+     * @return array<string,array{AdapterInterface}>
+     */
+    public static function imageReaders(): array
+    {
+        return [
+            'native' => [new Native()],
+            'imagick' => [new ImageMagick()],
+            'exiftool' => [new Exiftool()],
+        ];
+    }
+
+    #[Group('motionphoto')]
+    #[DataProvider('imageReaders')]
+    public function testMotionPhotoV1(AdapterInterface $adapter): void
+    {
+        $exif = (new Reader($adapter))->read(PHPEXIF_TEST_ROOT . '/files/motion_photo_v1.jpg');
+
+        $this->assertSame(self::VIDEO_LENGTH, $exif->getMicroVideoOffset());
+    }
+
+    #[Group('motionphoto')]
+    #[DataProvider('imageReaders')]
+    public function testUltraHdrMotionPhotoSkipsTheGainMap(AdapterInterface $adapter): void
+    {
+        $exif = (new Reader($adapter))->read(PHPEXIF_TEST_ROOT . '/files/motion_photo_ultrahdr.jpg');
+
+        $this->assertSame(self::VIDEO_LENGTH, $exif->getMicroVideoOffset());
+    }
+
+    #[Group('motionphoto')]
+    #[DataProvider('imageReaders')]
+    public function testPlainPhotoHasNoVideo(AdapterInterface $adapter): void
+    {
+        $exif = (new Reader($adapter))->read(PHPEXIF_TEST_ROOT . '/files/mongolia.jpeg');
+
+        $this->assertFalse($exif->getMicroVideoOffset());
+    }
+
+    #[Group('motionphoto')]
+    public function testAdapterValueIsKept(): void
+    {
+        $adapter = $this->createStub(AdapterInterface::class);
+        $adapter->method('getExifFromFile')->willReturn((new Exif())->setMicroVideoOffset('123'));
+
+        $exif = (new Reader($adapter))->read(PHPEXIF_TEST_ROOT . '/files/motion_photo_v1.jpg');
+
+        $this->assertSame('123', $exif->getMicroVideoOffset());
+    }
+
+    #[Group('motionphoto')]
+    public function testVideosAreLeftAlone(): void
+    {
+        $adapter = $this->createStub(AdapterInterface::class);
+        $adapter->method('getExifFromFile')->willReturn(new Exif());
+
+        $exif = (new Reader($adapter))->read(PHPEXIF_TEST_ROOT . '/files/IMG_3824.MOV');
+
+        $this->assertFalse($exif->getMicroVideoOffset());
+    }
+}
diff --git a/tests/files/motion_photo_ultrahdr.jpg b/tests/files/motion_photo_ultrahdr.jpg
new file mode 100644
index 0000000..4784e0a
Binary files /dev/null and b/tests/files/motion_photo_ultrahdr.jpg differ
diff --git a/tests/files/motion_photo_v1.jpg b/tests/files/motion_photo_v1.jpg
new file mode 100644
index 0000000..0b1bdc4
Binary files /dev/null and b/tests/files/motion_photo_v1.jpg differ