From 3db4d03e2df3857d9278aa0fc090cb0c8cf69d74 Mon Sep 17 00:00:00 2001
From: Caglar Pir <caglarp@meta.com>
Date: Fri, 23 Oct 2026 12:05:16 +0200
Subject: [PATCH 1/5] Read a video's GPS clock as a straight line at the rate
 it fits

Since #888, GPX sync places a track, and sampling stamps frames, through
every GPS timestamp of the video. The cameras whose timestamps leave a
straight line record in real time, so video time maps to GPS time along
a straight line, and their timestamps jitter about it. A GoPro stamps
each block of 1.001 seconds of video up to 1.7 seconds off the line
through the rest: on a GoPro MAX, the accelerometer timestamps of those
blocks advance 0.996 to 1.006 seconds each, while their GPS timestamps
advance 0 to 3.8 seconds. A PANOX V2 stamps some fixes up to 6 seconds
late.

#888 followed that jitter. It placed a GPX up to 1.4 s off the line on a
GoPro HERO7, 1.6 to 2.9 s on GoPro MAX videos with poor GPS, and 5.9 s
on a PANOX V2. It stamped interval samples 5 s apart from 3.7 to 6.3 s
apart (HERO7), and 10 s apart from 7.2 to 12.8 s apart (PANOX V2). Its
message put the move of a GPX on a GoPro MAX at up to 56 ms, and that of
GoPro interval stamps at up to 1.5 s; on these videos, both moved by up
to 2.9 s.

The LabPano Pilot One and Era, which #888 was written for, need no more
than a straight clock. Their timestamps fit one at 1.143 GPS seconds per
second of video, within 0.3 s over 14 minutes (0.7 s on the Era). The
clock was read at 1x only because any rate below the timelapse rate of
1.5 was rounded to 1.

Read the clock as the least-squares line through the timestamps, at the
rate it fits, anchored at their median as before, and use it everywhere:
GPX sync places the track by it, interval samples and distance samples
of the video's own track are stamped by it, and the geotagging stage
times the video's track at its rate. The fit leaves out the timestamps
that #888 showed to be wrong: those out of order, those before a jump of
more than a day, and stale first ones.

The rate is 1x when it is within 5% of 1x, or when it departs from 1x by
less than 2 seconds over the timestamps. On sample videos, cameras that
record in real time measure within 0.4% of 1x over 20 seconds or more,
or 1.6% for a GoPro MAX whose GPS glitches. Clips of a few seconds
measure up to 14% off 1x, a drift of at most 0.3 s. The LabPanos measure
1.093 to 1.143, a drift of at least 15 s. A rate above 1.5 must still
show in the median step between timestamps, so one timestamp far off
makes no timelapse. Timelapses get a straight clock too. Once their
stale first timestamps are left out, those of GoPro MAX, MAX 2 and Rove
timelapses lie within 0.33 GPS seconds of the line, but for one GoPro
MAX timelapse within 0.82 (55 ms of video), less than the jitter of a
normal video.

On sample videos from 9 cameras:

- Without a GPX, process writes the same tracks for all of them.
- A GPX made from a video's own track moves onto the straight line: by
  up to 1.4 s on the HERO7, 2.9 s and 1.6 s on GoPro MAX videos with
  poor GPS, 0.65 s on a GoPro MAX 2, 5.9 s on a PANOX V2, and up to
  0.06 s on other GoPros. Interval samples are stamped evenly, 5.000 s
  or 10.000 s apart, and those of a LabPano 11.426 s apart for 10 s of
  video. Distance samples of the video's own track are stamped by the
  clock, and their positions do not change.
- A GPX made from a LabPano's own track lands within 0.26 s of its
  timestamps over 14 minutes, and within 0.61 s on the Era. GPX distance
  samples of the 2 fps Era are no longer dropped: #888 timed its frames
  alternately fast and slow, so half of them fell under the sample
  distance. One LabPano video is the exception: its GPS drops out for 6
  seconds of video, its positions jump 64 m, and its GPS time advances
  2 s over 8 seconds of video. A GPX of its own track is placed up to
  3.8 s off its timestamps, and interval samples geotagged from it up to
  65 m off its own positions.
- GoPro MAX timelapses keep #852's results: their placements move by up
  to 0.05 s, and all their distance samples are described.
- A GPX that ends exactly at a video's own first or last timestamp, as
  one made from its track does, can now miss a sample at the very start
  or end of the video, which is stamped just past it and reported as
  outside the track: 1 to 4 samples on 4 of these videos. A logger track
  that covers the video does not.
- BlackVue, Viofo and Ricoh outputs do not change, but for 1 ms rounding
  of BlackVue GPX track times.
---
 .../geotag/geotag_images_from_video.py        |  16 +-
 .../geotag/video_extractors/gpx.py            | 292 +++++++-----------
 mapillary_tools/sample_video.py               |  78 ++---
 tests/integration/test_gopro.py               |  21 +-
 tests/integration/test_process.py             |  21 +-
 tests/integration/test_upload.py              |   9 +-
 tests/unit/test_geotag_images_from_video.py   |  38 +--
 tests/unit/test_gpx_video_clip.py             |  19 +-
 tests/unit/test_gpx_video_clock.py            |  10 +-
 tests/unit/test_gpx_video_sync.py             |  28 +-
 ...meline.py => test_gpx_video_timestamps.py} | 213 +++++++------
 tests/unit/test_sample_video.py               |  72 +++--
 12 files changed, 367 insertions(+), 450 deletions(-)
 rename tests/unit/{test_gps_timeline.py => test_gpx_video_timestamps.py} (50%)

diff --git a/mapillary_tools/geotag/geotag_images_from_video.py b/mapillary_tools/geotag/geotag_images_from_video.py
index 092fe2f42..6422a5c99 100644
--- a/mapillary_tools/geotag/geotag_images_from_video.py
+++ b/mapillary_tools/geotag/geotag_images_from_video.py
@@ -20,7 +20,7 @@
 from .base import GeotagImagesFromGeneric
 from .geotag_images_from_gpx import GeotagImagesFromGPX
 from .geotag_videos_from_video import GeotagVideosFromVideo
-from .video_extractors.gpx import GPSTimeline, GPXVideoExtractor
+from .video_extractors.gpx import GPXVideoExtractor
 
 
 LOG = logging.getLogger(__name__)
@@ -109,21 +109,15 @@ def _on_capture_timeline(
     ) -> T.Sequence[geo.Point]:
         """
         Time the video's GPS points in GPS seconds from the start of the video,
-        like the samples, which are stamped with their capture times, as its
-        GPS timestamps tell: a timelapse packs several into each second of
+        like the samples, which are stamped with their capture times, at the
+        pace of its GPS clock: a timelapse packs several into each second of
         video, and some clocks gain on the video.
         """
         clock = GPXVideoExtractor._read_video_clock(points)
-        if clock is None:
+        if clock is None or clock.rate == 1.0:
             return points
 
-        timeline = GPSTimeline.read(points, clock.rate)
-        assert timeline is not None, "a GPS clock is read from GPS timestamps"
-        start = timeline.to_unix_time(0.0)
-        return [
-            dataclasses.replace(p, time=timeline.to_unix_time(p.time) - start)
-            for p in points
-        ]
+        return [dataclasses.replace(p, time=p.time * clock.rate) for p in points]
 
 
 class GeotagImageSamplesFromVideo(GeotagImagesFromGeneric):
diff --git a/mapillary_tools/geotag/video_extractors/gpx.py b/mapillary_tools/geotag/video_extractors/gpx.py
index 02a0ebd1f..3144a6824 100644
--- a/mapillary_tools/geotag/video_extractors/gpx.py
+++ b/mapillary_tools/geotag/video_extractors/gpx.py
@@ -46,9 +46,10 @@
 # a GPS logger left running after the video, but a log of several trips
 _MAX_RECORDING_SECONDS = 24 * 3600
 
-# A GPS clock that runs this much faster than the video clock is a timelapse.
-# Normal videos stay well below it, although over a few seconds of GPS
-# timestamped once per block the estimate can be 20% off
+# A GPS clock that runs this much faster than the video clock is a timelapse,
+# and the steps between its timestamps show it too. One timestamp far off the
+# rest, or one step of the clock, can pull the least-squares slope of a normal
+# video past it
 _MIN_TIMELAPSE_RATE = 1.5
 
 # No GPS fix can be timestamped before the GPS epoch, 1980-01-06. GPX files
@@ -70,6 +71,18 @@
 # in steps of a second per half second, 2 minutes over a 14-minute video
 _STALE_STEP_RATE = 1.5
 
+# A GPS clock that runs within this fraction of the video's pace runs at it.
+# Over 20 seconds or more, cameras that record in real time measure within
+# 0.4% of 1x, or 1.6% for a GoPro MAX whose GPS glitches, while the clock of a
+# LabPano runs 9% to 14% faster than its video
+_MAX_CLOCK_RATE_ERROR = 0.05
+
+# Nor can GPS timestamps measure a clock that departs from the video's pace by
+# less than their own jitter over the video time they span: GoPro stamps blocks
+# of points up to 1.7 seconds off the line through the rest, and clips a few
+# seconds long measure up to 15% off 1x, if by no more than 0.3 seconds
+_MAX_CLOCK_DRIFT_SECONDS = 2.0
+
 
 class SyncMode(enum.Enum):
     # Sync by video GPS timestamps if found, otherwise rebase
@@ -83,7 +96,10 @@ class SyncMode(enum.Enum):
 @dataclasses.dataclass(frozen=True)
 class VideoClock:
     """
-    Maps between the video time and the Unix time of the GPS clock in the video
+    Maps between the video time and the Unix time of the GPS clock in the video:
+    a straight line, as a camera records its frames at a steady pace, whether
+    in real time or as a timelapse. The GPS timestamps of the video jitter
+    about it
 
     >>> clock = VideoClock(video_time=2.0, unix_time=1000.0)
     >>> clock.to_video_time(1030.0)
@@ -107,124 +123,6 @@ def to_unix_time(self, video_time: float) -> float:
         return self.unix_time + (video_time - self.video_time) * self.rate
 
 
-@dataclasses.dataclass(frozen=True)
-class GPSTimeline:
-    """
-    The Unix time of the video's GPS clock along the video: interpolated
-    between its GPS timestamps, and extrapolated beyond them at the clock's
-    rate. A straight clock does not follow them: the clock of a timelapse
-    drifts from its rate over the video, the first timestamp of a GoPro MAX
-    timelapse can be seconds early, and some cameras gain on the video in
-    steps.
-
-    >>> timeline = GPSTimeline((0.0, 1.0, 2.0), (100.0, 104.0, 114.0), rate=10.0)
-    >>> timeline.to_unix_time(0.5)
-    102.0
-    >>> timeline.to_unix_time(3.0)
-    124.0
-    >>> timeline.to_video_time(109.0)
-    1.5
-    >>> timeline.to_video_time(95.0)
-    -0.5
-    >>> timeline.starting_at(1.0, 200.0).to_unix_time(2.0)
-    210.0
-    """
-
-    video_times: tuple[float, ...]
-    unix_times: tuple[float, ...]
-    # GPS seconds per video second beyond the timestamps
-    rate: float
-
-    @classmethod
-    def read(cls, points: T.Sequence[geo.Point], rate: float) -> GPSTimeline | None:
-        """
-        Read the timeline from the GPS timestamps of the points, or None if they
-        have none. Leave out the timestamps that the others show to be wrong:
-        those out of order, those before a jump of days (from a placeholder
-        date to the GPS time), and stale first ones.
-        """
-        pairs: list[tuple[float, float]] = []
-        for p in points:
-            unix_time = p.get_unix_time()
-            if unix_time is None:
-                continue
-            if pairs and unix_time == pairs[-1][1]:
-                # GoPro GPS5 stamps a whole block (~1s) of points with one
-                # timestamp. Keep the first point of the block
-                continue
-            if pairs and p.time <= pairs[-1][0]:
-                # Two timestamps at one video time
-                continue
-            pairs.append((p.time, unix_time))
-
-        # A timestamp out of order with the others is wrong, and could not be
-        # interpolated back to the video
-        pairs = _increasing_subsequence(pairs)
-        if not pairs:
-            return None
-
-        # GoPro stamps a placeholder date until the GPS acquires the time
-        start = 0
-        for idx in range(1, len(pairs)):
-            (v0, u0), (v1, u1) = pairs[idx - 1], pairs[idx]
-            if _IMPLAUSIBLE_OFFSET_SECONDS < (u1 - u0) - (v1 - v0) * rate:
-                start = idx
-
-        # Stale first timestamps (see _STALE_STEP_RATE). Judged by the steps of
-        # the rest, not by the rate: that is 1 for timestamps over less than a
-        # second of video, as those of a short timelapse, too few to measure it
-        pace = GPXVideoExtractor._median_step_rate(pairs[start + 1 :])
-        while pace is not None and start + 1 < len(pairs):
-            (v0, u0), (v1, u1) = pairs[start], pairs[start + 1]
-            if (u1 - u0) <= (v1 - v0) * pace * _STALE_STEP_RATE:
-                break
-            start += 1
-
-        return cls(
-            video_times=tuple(v for v, _ in pairs[start:]),
-            unix_times=tuple(u for _, u in pairs[start:]),
-            rate=rate,
-        )
-
-    def to_unix_time(self, video_time: float) -> float:
-        return _interpolate_line(
-            self.video_times, self.unix_times, video_time, self.rate
-        )
-
-    def to_video_time(self, unix_time: float) -> float:
-        return _interpolate_line(
-            self.unix_times, self.video_times, unix_time, 1 / self.rate
-        )
-
-    def starting_at(self, video_time: float, unix_time: float) -> GPSTimeline:
-        """
-        The timeline shifted to be at **unix_time** at **video_time**: at the
-        pace of the GPS clock, from a start that the clock does not tell
-        """
-        shift = unix_time - self.to_unix_time(video_time)
-        return dataclasses.replace(
-            self, unix_times=tuple(u + shift for u in self.unix_times)
-        )
-
-
-def _interpolate_line(
-    xs: T.Sequence[float], ys: T.Sequence[float], x: float, slope: float
-) -> float:
-    """
-    Interpolate y at x along the line through the points (xs, ys), xs in
-    increasing order, and extrapolate it beyond them at **slope**
-    """
-    idx = bisect.bisect_right(xs, x)
-    if 0 < idx < len(xs):
-        x0, x1 = xs[idx - 1], xs[idx]
-        y0, y1 = ys[idx - 1], ys[idx]
-        return y0 + (y1 - y0) * (x - x0) / (x1 - x0)
-
-    # Before the first point or after the last
-    anchor = 0 if idx == 0 else -1
-    return ys[anchor] + (x - xs[anchor]) * slope
-
-
 def _increasing_subsequence(
     pairs: T.Sequence[tuple[float, float]],
 ) -> list[tuple[float, float]]:
@@ -315,9 +213,7 @@ def extract(self) -> types.VideoMetadata:
             )
 
         video_clock = self._read_video_clock(native_video_metadata.points)
-        clock: VideoClock | GPSTimeline | None = self._sync_clock(
-            video_clock, gpx_points, noisy
-        )
+        clock = self._sync_clock(video_clock, gpx_points, noisy)
         if video_clock is not None and clock is None:
             LOG.warning(
                 "The GPS clock of %s, whose GPS was rejected as noise, is %.1f days away from %s. "
@@ -327,17 +223,10 @@ def extract(self) -> types.VideoMetadata:
                 self.gpx_path,
                 self.file_format,
             )
-        if clock is not None and not noisy:
-            # Through the GPS timestamps of the video, which no straight clock
-            # follows. GPS rejected as noise gives the clock only
-            timeline = GPSTimeline.read(native_video_metadata.points, clock.rate)
-            assert timeline is not None, "a GPS clock is read from GPS timestamps"
-            clock = timeline
         if clock is not None and gpx_points and self.sync_mode is SyncMode.REBASE:
-            # At the pace of the GPS clock from the start of the track, which
-            # distance sampling, reading the frames by their composition times,
-            # puts at that of the first frame
-            clock = self._start_with_the_video(clock, gpx_points[0].time)
+            # Distance sampling reads the frames by their composition times:
+            # start the track at that of the first frame
+            clock = dataclasses.replace(clock, video_time=self._gpx_start_video_time())
 
         if clock is None:
             # Its GPS has no clock to sync with, as if it had no GPS
@@ -359,7 +248,7 @@ def extract(self) -> types.VideoMetadata:
                 )
             if clock.rate != 1.0:
                 LOG.info(
-                    "The GPS clock in %s runs %.1f times faster than the video (timelapse). Syncing %s accordingly",
+                    "The GPS clock in %s runs %.3g times faster than the video. Syncing %s accordingly",
                     self.video_path,
                     clock.rate,
                     self.gpx_path,
@@ -424,7 +313,7 @@ def _parse_tracks(self) -> list[list[geo.Point]]:
             ) from ex
 
     def _clip_to_video(
-        self, gpx_points: list[geo.Point], clock: VideoClock | GPSTimeline | None
+        self, gpx_points: list[geo.Point], clock: VideoClock | None
     ) -> list[geo.Point]:
         """
         Clip a GPX track to the video, from video time 0 to where the video
@@ -486,20 +375,6 @@ def _place_without_video_gps(
         self._rebase_times(gpx_points, rate=ratio)
         return None
 
-    def _start_with_the_video(
-        self, clock: VideoClock | GPSTimeline, gpx_start_time: float
-    ) -> VideoClock | GPSTimeline:
-        """
-        The **clock** moved to start the track, at **gpx_start_time**, with
-        the video, as --interpolation_use_gpx_start_time says it does
-        """
-        video_time = self._gpx_start_video_time()
-        if isinstance(clock, GPSTimeline):
-            return clock.starting_at(video_time, gpx_start_time)
-        return VideoClock(
-            video_time=video_time, unix_time=gpx_start_time, rate=clock.rate
-        )
-
     def _gpx_start_video_time(self) -> float:
         """
         The video time that --interpolation_use_gpx_start_time starts the GPX
@@ -557,7 +432,7 @@ def _check_coverage(
         gpx_points: T.Sequence[geo.Point],
         gpx_unix_times: tuple[float, float] | None,
         video_gps_points: T.Sequence[geo.Point],
-        clock: VideoClock | GPSTimeline | None,
+        clock: VideoClock | None,
         rate: float,
     ) -> None:
         """
@@ -969,7 +844,12 @@ def _read_video_clock(
         cls, video_gps_points: T.Sequence[geo.Point]
     ) -> VideoClock | None:
         """
-        Read the GPS clock from the video GPS points, or None if they have no timestamps
+        Read the GPS clock from the video GPS points, or None if they have no
+        timestamps: the straight line that their timestamps fit, at 1x unless
+        they measure a pace off it. The fit assumes that the clock runs at a
+        steady pace, as the camera records its frames: a step of the clock, or
+        a GPS dropout that it does not recover from, leaves the timestamps off
+        any line
 
         >>> GPXVideoExtractor._read_video_clock([]) is None
         True
@@ -977,9 +857,54 @@ def _read_video_clock(
         >>> GPXVideoExtractor._read_video_clock([point]) is None
         True
         """
-        # (video time, Unix time) pairs
-        pairs: list[tuple[float, float]] = []
+        pairs = cls._read_timestamps(video_gps_points)
+        if not pairs:
+            return None
+
+        rate = cls._estimate_clock_rate(pairs)
+        if rate is None or abs(rate - 1.0) <= max(
+            _MAX_CLOCK_RATE_ERROR,
+            _MAX_CLOCK_DRIFT_SECONDS / (pairs[-1][0] - pairs[0][0]),
+        ):
+            # See _MAX_CLOCK_RATE_ERROR and _MAX_CLOCK_DRIFT_SECONDS
+            rate = 1.0
+        elif _MIN_TIMELAPSE_RATE < rate:
+            # A timestamp far off the rest, or a step of the clock, can pull the
+            # least-squares slope far off, so a timelapse must show in the
+            # median step between neighbouring pairs too. That is too coarse to
+            # measure the rate, but not to tell a timelapse from a normal video
+            step_rate = cls._median_step_rate(pairs)
+            if step_rate is None or step_rate <= _MIN_TIMELAPSE_RATE:
+                rate = 1.0
+
+        # Anchored at its own video time, which is not 0 when the video's GPS
+        # starts late (e.g. GoPro drops noisy fixes at the start of a recording),
+        # and at the median of all its timestamps mapped back to that time, not
+        # at the first alone: GPS clocks jitter by a second or so against the
+        # video, and a PANOX V2 stamps some fixes seconds late
+        video_time = pairs[0][0]
+        unix_time = statistics.median(u - (v - video_time) * rate for v, u in pairs)
 
+        return VideoClock(video_time=video_time, unix_time=unix_time, rate=rate)
+
+    @classmethod
+    def _read_timestamps(
+        cls, video_gps_points: T.Sequence[geo.Point]
+    ) -> list[tuple[float, float]]:
+        """
+        Read the (video time, Unix time) pairs of the GPS timestamps of the
+        points, leaving out those that the others show to be wrong: those out
+        of order, those before a jump of days (from a placeholder date to the
+        GPS time), and stale first ones
+
+        >>> points = [
+        ...     telemetry.GPSPoint(time=v, lat=1, lon=1, alt=None, angle=None, epoch_time=u, fix=None, precision=None, ground_speed=None)
+        ...     for v, u in [(0, 992.4), (0.4, 1000.4), (1.4, 1001.4), (1.8, 1001.4), (2.4, 1002.4)]
+        ... ]
+        >>> GPXVideoExtractor._read_timestamps(points)
+        [(0.4, 1000.4), (1.4, 1001.4), (2.4, 1002.4)]
+        """
+        pairs: list[tuple[float, float]] = []
         for p in video_gps_points:
             # Video GPS timestamps are stored in whatever epoch their container
             # uses (CAMM records GPS time, GoPro records Unix time), so go
@@ -991,51 +916,50 @@ def _read_video_clock(
                 # GoPro GPS5 stamps a whole block (~1s) of points with one
                 # timestamp. Keep the first point of the block
                 continue
+            if pairs and p.time <= pairs[-1][0]:
+                # Two timestamps at one video time
+                continue
             pairs.append((p.time, unix_time))
 
-        if not pairs:
-            return None
+        # A timestamp out of order with the others is wrong
+        pairs = _increasing_subsequence(pairs)
 
-        rate = cls._estimate_clock_rate(pairs)
-        # One timestamp far off (e.g. a placeholder date before GPS time is
-        # acquired) can pull the least-squares slope far off, so a timelapse
-        # must show in the median step between neighbouring pairs too. That is
-        # too coarse to measure the rate, but not to tell a timelapse from a
-        # normal video
-        step_rate = cls._median_step_rate(pairs)
-        if not (
-            rate is not None
-            and _MIN_TIMELAPSE_RATE < rate
-            and step_rate is not None
-            and _MIN_TIMELAPSE_RATE < step_rate
-        ):
-            rate = 1.0
+        pace = cls._median_step_rate(pairs)
+        if pace is None:
+            return pairs
 
-        # Anchored at its own video time, which is not 0 when the video's GPS
-        # starts late (e.g. GoPro drops noisy fixes at the start of a recording),
-        # and at the median of all its timestamps mapped back to that time, not
-        # at the first alone: that can be seconds off the rest (the first GPS
-        # block of a GoPro timelapse, a stale first fix), and some GPS clocks
-        # wander by a second or so against the video
-        video_time = pairs[0][0]
-        unix_time = statistics.median(u - (v - video_time) * rate for v, u in pairs)
+        # GoPro stamps a placeholder date until the GPS acquires the time
+        start = 0
+        for idx in range(1, len(pairs)):
+            (v0, u0), (v1, u1) = pairs[idx - 1], pairs[idx]
+            if _IMPLAUSIBLE_OFFSET_SECONDS < (u1 - u0) - (v1 - v0) * pace:
+                start = idx
 
-        return VideoClock(video_time=video_time, unix_time=unix_time, rate=rate)
+        # Stale first timestamps (see _STALE_STEP_RATE). Judged by the steps of
+        # the rest: the rate is fitted to the timestamps that are left
+        pace = cls._median_step_rate(pairs[start + 1 :])
+        while pace is not None and start + 1 < len(pairs):
+            (v0, u0), (v1, u1) = pairs[start], pairs[start + 1]
+            if (u1 - u0) <= (v1 - v0) * pace * _STALE_STEP_RATE:
+                break
+            start += 1
+
+        return pairs[start:]
 
     @classmethod
     def _estimate_clock_rate(
         cls, pairs: T.Sequence[tuple[float, float]]
     ) -> float | None:
         """
-        Least-squares slope of the Unix time over the video time, or None if the
-        pairs span less than a second of video
+        Least-squares slope of the Unix time over the video time, or None
+        without two pairs at different video times
 
         >>> GPXVideoExtractor._estimate_clock_rate([(0, 100), (1, 115), (2, 130)])
         15.0
-        >>> GPXVideoExtractor._estimate_clock_rate([(0, 100), (0.5, 107.5)]) is None
+        >>> GPXVideoExtractor._estimate_clock_rate([(0, 100)]) is None
         True
         """
-        if len(pairs) < 2 or pairs[-1][0] - pairs[0][0] < 1.0:
+        if len(pairs) < 2 or pairs[-1][0] <= pairs[0][0]:
             return None
 
         n = len(pairs)
diff --git a/mapillary_tools/sample_video.py b/mapillary_tools/sample_video.py
index 2ebcf24ce..17a47840c 100644
--- a/mapillary_tools/sample_video.py
+++ b/mapillary_tools/sample_video.py
@@ -36,7 +36,7 @@
     SourceType,
     VideoSyncOption,
 )
-from .geotag.video_extractors.gpx import GPSTimeline, GPXVideoExtractor, VideoClock
+from .geotag.video_extractors.gpx import GPXVideoExtractor, VideoClock
 from .geotag.video_extractors.native import NativeVideoExtractor
 from .geotag.video_extractors.nmea import NMEAVideoExtractor
 from .mp4 import mp4_sample_parser, simple_mp4_parser as sparser
@@ -473,12 +473,12 @@ def _read_telemetry(video_path: Path) -> T.Sequence[geo.Point]:
     return []
 
 
-def _telemetry_clock_rate(
+def _telemetry_clock(
     video_path: Path, telemetry_points: T.Sequence[geo.Point]
-) -> float | None:
+) -> VideoClock | None:
     """
-    GPS seconds per video second of the video's own GPS clock: more than 1 if
-    the video is a timelapse, or None if it has no GPS clock
+    The video's own GPS clock, or None if it has none. It runs more than 1 GPS
+    second per video second if the video is a timelapse
     """
     clock = GPXVideoExtractor._read_video_clock(telemetry_points)
     if clock is None:
@@ -486,11 +486,11 @@ def _telemetry_clock_rate(
 
     if clock.rate != 1.0:
         LOG.info(
-            "The GPS clock in %s runs %.1f times faster than the video (timelapse)",
+            "The GPS clock in %s runs %.3g times faster than the video",
             video_path.name,
             clock.rate,
         )
-    return clock.rate
+    return clock
 
 
 def _parse_filename_time(video_path: Path) -> datetime.datetime | None:
@@ -770,48 +770,36 @@ def _sample_single_video_by_interval(
     telemetry_points = _read_telemetry(video_path)
 
     # Frames are stamped with their capture times, which a timelapse packs
-    # several seconds of into each second of video: as the video's own GPS
-    # timestamps tell, and for a video without a GPS clock, at
-    # --video_duration_ratio
-    clock_rate = _telemetry_clock_rate(video_path, telemetry_points)
+    # several seconds of into each second of video: by the video's own GPS
+    # clock, as GPX sync places a GPX and distance samples are stamped, and for
+    # a video without a GPS clock, at --video_duration_ratio
+    clock = _telemetry_clock(video_path, telemetry_points)
     # GPS rejected as noise gives no telemetry, but GPX sync reads its clock,
     # and the frames are stamped by it, where GPX sync places them along the
     # GPX, so that the geotagging stage finds them there
-    gpx_clock: VideoClock | None = None
-    if clock_rate is None:
-        gpx_clock = _gpx_sync_clock(video_path, geotag_options)
-        if gpx_clock is not None:
-            clock_rate = gpx_clock.rate
-    timeline: GPSTimeline | None = None
-    if clock_rate is None:
+    if clock is None:
+        clock = _gpx_sync_clock(video_path, geotag_options)
+    if clock is None:
         rate = duration_ratio
     else:
-        rate = clock_rate
+        rate = clock.rate
         if duration_ratio != 1.0:
             LOG.warning(
                 "Ignoring --video_duration_ratio %g for %s, whose own GPS clock runs at %.3gx",
                 duration_ratio,
                 video_path.name,
-                clock_rate,
+                clock.rate,
             )
-        if gpx_clock is None:
-            # As distance samples are stamped, and as the geotagging stage
-            # times the video's track to place the samples along it
-            timeline = GPSTimeline.read(telemetry_points, clock_rate)
 
-    if clock_rate is None and video_sync is not None:
+    if clock is None and video_sync is not None:
         _check_gpx_start_by_interval(video_path, geotag_options, video_sync)
 
     probe = _probe_video(ffmpeg, video_path)
 
     if start_time is None:
-        if timeline is not None:
+        if clock is not None:
             start_time = datetime.datetime.fromtimestamp(
-                timeline.to_unix_time(0.0), tz=datetime.timezone.utc
-            )
-        elif gpx_clock is not None:
-            start_time = datetime.datetime.fromtimestamp(
-                gpx_clock.to_unix_time(0.0), tz=datetime.timezone.utc
+                clock.to_unix_time(0.0), tz=datetime.timezone.utc
             )
         else:
             start_time = _extract_video_start_time(video_path, probe, telemetry_points)
@@ -843,11 +831,7 @@ def _sample_single_video_by_interval(
                 continue
             # extract_frames() produces 1-based frame indices so we need to subtract 1 here
             video_time = (frame_idx_1based - 1) * sample_interval
-            if timeline is None:
-                seconds = video_time * rate
-            else:
-                seconds = timeline.to_unix_time(video_time) - timeline.to_unix_time(0.0)
-            timestamp = start_time + datetime.timedelta(seconds=seconds)
+            timestamp = start_time + datetime.timedelta(seconds=video_time * rate)
             exif_edit = ExifEdit(sample_paths[0])
             exif_edit.add_date_time_original(timestamp)
             exif_edit.add_gps_datetime(timestamp)
@@ -1057,11 +1041,11 @@ def _sample_single_video_by_distance(
     last_unix_time = max(track_unix_times, default=None)
 
     # Read from the video itself, a track with a GPS clock of its own paces the
-    # video, and stamps the frames along its timeline, as interval samples are.
-    # A GPX source warns of the options that its sync ignores itself, and its
-    # sync placed the track along the video's clock already: its timestamps
-    # stamp the frames as they are
-    track_timeline: GPSTimeline | None = None
+    # video, and its clock stamps the frames, as interval samples are. A GPX
+    # source warns of the options that its sync ignores itself, and its sync
+    # placed the track along the video's clock already: its timestamps stamp
+    # the frames as they are
+    track_clock: VideoClock | None = None
     if not any(
         option.source in factory.EXTERNAL_GPS_SOURCES for option in geotag_options
     ):
@@ -1073,14 +1057,12 @@ def _sample_single_video_by_distance(
             start_time,
         )
         track_clock = GPXVideoExtractor._read_video_clock(video_metadata.points)
-        if track_clock is not None:
-            track_timeline = GPSTimeline.read(video_metadata.points, track_clock.rate)
 
-    # Frames along the timeline, or at points with an absolute timestamp, are
-    # timestamped from it below, so only the others need the start time
+    # Frames stamped by the clock, or at points with an absolute timestamp,
+    # are timestamped below, so only the others need the start time
     if (
         start_time is None
-        and track_timeline is None
+        and track_clock is None
         and any(
             interp.get_unix_time() is None
             for _, interp in sample_points_by_frame_idx.values()
@@ -1130,8 +1112,8 @@ def _sample_single_video_by_distance(
 
             gps_unix_time = (
                 interp.get_unix_time()
-                if track_timeline is None
-                else track_timeline.to_unix_time(interp.time)
+                if track_clock is None
+                else track_clock.to_unix_time(interp.time)
             )
             if gps_unix_time is not None:
                 assert first_unix_time is not None and last_unix_time is not None
diff --git a/tests/integration/test_gopro.py b/tests/integration/test_gopro.py
index 115d79507..e7589e452 100644
--- a/tests/integration/test_gopro.py
+++ b/tests/integration/test_gopro.py
@@ -31,16 +31,17 @@
     "MAPILLARY_TOOLS_GOPRO_GPS_PRECISION": "10000000",
     "MAPILLARY_TOOLS_MAX_CAPTURE_SPEED_KMH": "2000000",  # km/h
 }
-# The capture times come from the GPMF GPS timestamps (which put the start at
-# 2019-11-18T23:42:10.009Z, without the first, 1.35 seconds stale), not from the
-# container's creation time. This camera writes the creation time in local time,
-# so reading the start time from there would timestamp every sample 8 hours off.
+# The capture times come from the GPMF GPS clock (which puts the start at
+# 2019-11-18T23:42:10.003Z, without the first timestamp, 1.36 seconds stale),
+# not from the container's creation time. This camera writes the creation time
+# in local time, so reading the start time from there would timestamp every
+# sample 8 hours off.
 EXPECTED_DESCS: T.List[T.Any] = [
     {
         "filename": "hero8.mp4/hero8_v_000001.jpg",
         "filetype": "image",
         "MAPAltitude": 9540.24,
-        "MAPCaptureTime": "2019_11_18_23_42_10_009",
+        "MAPCaptureTime": "2019_11_18_23_42_10_003",
         "MAPCompassHeading": {
             "TrueHeading": 123.93587938690177,
             "MagneticHeading": 123.93587938690177,
@@ -55,7 +56,7 @@
         "filename": "hero8.mp4/hero8_v_000002.jpg",
         "filetype": "image",
         "MAPAltitude": 7112.573717404068,
-        "MAPCaptureTime": "2019_11_18_23_42_12_052",
+        "MAPCaptureTime": "2019_11_18_23_42_12_003",
         "MAPCompassHeading": {
             "TrueHeading": 140.8665026186285,
             "MagneticHeading": 140.8665026186285,
@@ -70,7 +71,7 @@
         "filename": "hero8.mp4/hero8_v_000003.jpg",
         "filetype": "image",
         "MAPAltitude": 7463.642846094319,
-        "MAPCaptureTime": "2019_11_18_23_42_13_976",
+        "MAPCaptureTime": "2019_11_18_23_42_14_003",
         "MAPCompassHeading": {
             "TrueHeading": 138.44255851085705,
             "MagneticHeading": 138.44255851085705,
@@ -85,7 +86,7 @@
         "filename": "hero8.mp4/hero8_v_000004.jpg",
         "filetype": "image",
         "MAPAltitude": 6909.8168472111465,
-        "MAPCaptureTime": "2019_11_18_23_42_16_009",
+        "MAPCaptureTime": "2019_11_18_23_42_16_003",
         "MAPCompassHeading": {
             "TrueHeading": 142.23462669862568,
             "MagneticHeading": 142.23462669862568,
@@ -100,7 +101,7 @@
         "filename": "hero8.mp4/hero8_v_000005.jpg",
         "filetype": "image",
         "MAPAltitude": 7212.594480737465,
-        "MAPCaptureTime": "2019_11_18_23_42_17_992",
+        "MAPCaptureTime": "2019_11_18_23_42_18_003",
         "MAPCompassHeading": {
             "TrueHeading": 164.70819093235514,
             "MagneticHeading": 164.70819093235514,
@@ -115,7 +116,7 @@
         "filename": "hero8.mp4/hero8_v_000006.jpg",
         "filetype": "image",
         "MAPAltitude": 7274.361994963208,
-        "MAPCaptureTime": "2019_11_18_23_42_20_019",
+        "MAPCaptureTime": "2019_11_18_23_42_20_003",
         "MAPCompassHeading": {
             "TrueHeading": 139.71549328876722,
             "MagneticHeading": 139.71549328876722,
diff --git a/tests/integration/test_process.py b/tests/integration/test_process.py
index a14abe558..46385de91 100644
--- a/tests/integration/test_process.py
+++ b/tests/integration/test_process.py
@@ -761,7 +761,7 @@ def test_process_video_geotag_source_with_gpx_outside_video(
     assert descs[0]["error"]["vars"] == {
         # Its first GPS timestamp is 23:44:42.590, a second before the rest
         # place the start of the video
-        "image_time": "2019_11_18_23_44_43_624",
+        "image_time": "2019_11_18_23_44_43_613",
         "gpx_start_time": "2025_03_14_07_00_00_000",
         "gpx_end_time": "2025_03_14_07_01_33_624",
     }
@@ -775,7 +775,7 @@ def test_process_video_from_gpx_with_interpolation_options(
     images. They were ignored for videos.
     """
     video_path = setup_data.join("gopro_data").join("max-360mode.mp4")
-    # 3.624 seconds before the GPS timestamps of the video place its start
+    # 3.613 seconds before the GPS clock of the video starts
     start = datetime.datetime(2019, 11, 18, 23, 44, 40, tzinfo=datetime.timezone.utc)
     points = "".join(
         f'<trkpt lat="{37.0 + i * 0.0001:.7f}" lon="-122.0">'
@@ -809,20 +809,19 @@ def video_time_of_recorded(*options: str) -> float:
         [point] = [p for p in describe(*options)["MAPGPSTrack"] if p[5] == recorded]
         return point[0]
 
-    # In ms of video, which the GPS timestamps of the video pace at a second
-    # per second, give or take their jitter of some 40 ms
     synced = video_time_of_recorded()
-    assert synced == pytest.approx(10000 - 3624, abs=50)
+    assert synced == pytest.approx(10000 - 3613, abs=1)
 
-    assert video_time_of_recorded("--interpolation_use_gpx_start_time") == (
-        pytest.approx(10000, abs=50)
+    assert video_time_of_recorded("--interpolation_use_gpx_start_time") == 10000
+    assert (
+        video_time_of_recorded(
+            "--interpolation_use_gpx_start_time", "--interpolation_offset_time=2.5"
+        )
+        == 7500
     )
-    assert video_time_of_recorded(
-        "--interpolation_use_gpx_start_time", "--interpolation_offset_time=2.5"
-    ) == pytest.approx(7500, abs=50)
 
     shifted = video_time_of_recorded("--interpolation_offset_time=2")
-    assert shifted == pytest.approx(synced - 2000, abs=50)
+    assert shifted == pytest.approx(synced - 2000, abs=1)
 
     # an offset that moves the track off the video fails it, as it does a
     # track placed by the clock of the video
diff --git a/tests/integration/test_upload.py b/tests/integration/test_upload.py
index 1afe1bb45..3bfa1e357 100644
--- a/tests/integration/test_upload.py
+++ b/tests/integration/test_upload.py
@@ -10,7 +10,7 @@
 
 import py.path
 import pytest
-from mapillary_tools.geotag.video_extractors.gpx import GPSTimeline, GPXVideoExtractor
+from mapillary_tools.geotag.video_extractors.gpx import GPXVideoExtractor
 from mapillary_tools.geotag.video_extractors.native import NativeVideoExtractor
 
 from .fixtures import (
@@ -52,9 +52,7 @@ def test_upload_video_with_gpx_running_past_both_ends(
     points = NativeVideoExtractor(Path(video_path)).extract().points
     clock = GPXVideoExtractor._read_video_clock(points)
     assert clock is not None
-    timeline = GPSTimeline.read(points, clock.rate)
-    assert timeline is not None
-    video_start = timeline.to_unix_time(0)
+    video_start = clock.to_unix_time(0)
     # From 12.5 seconds before the video to about 47 seconds after it
     trkpts = "".join(
         f'<trkpt lat="{37.0 + i * 0.0001:.7f}" lon="-122.0"><time>'
@@ -85,8 +83,7 @@ def test_upload_video_with_gpx_running_past_both_ends(
     assert first[0] == 0
     assert first[2] == pytest.approx(37.0 + 12.5 * 0.0001, abs=1e-7)
     assert first[5] == pytest.approx(video_start, abs=1e-3)
-    # The CAMM track of the uploaded video truncates the time between samples
-    assert last[0] == pytest.approx(duration * 1000, abs=2)
+    assert last[0] == pytest.approx(duration * 1000, abs=1)
     assert last[5] == pytest.approx(video_start + duration, abs=1e-3)
 
 
diff --git a/tests/unit/test_geotag_images_from_video.py b/tests/unit/test_geotag_images_from_video.py
index d745552d3..ae350c033 100644
--- a/tests/unit/test_geotag_images_from_video.py
+++ b/tests/unit/test_geotag_images_from_video.py
@@ -85,30 +85,26 @@ def test_samples_are_placed_by_their_capture_times(tmp_path: Path, rate: float):
     }
 
 
-def test_timelapse_samples_are_placed_by_the_gps_timestamps(tmp_path: Path):
+def test_timelapse_samples_are_placed_by_the_gps_clock(tmp_path: Path):
     """
-    Distance samples are stamped with the GPS time of their video time. A
-    GoPro MAX timelapse can stamp its first point seconds early, and its clock
-    keeps no one rate, so timed at one rate the track placed the samples off,
-    and the last ones past its end.
+    Samples are stamped by the GPS clock of the video. A GoPro MAX timelapse
+    can stamp its first point seconds early, and timed from it, the track
+    placed the samples off, and the last ones past its end.
     """
     video_path = tmp_path / "hello.mp4"
     sample_dir = tmp_path / "samples" / "hello.mp4"
     sample_dir.mkdir(parents=True)
 
-    # 10x, but the first timestamp 3 seconds early and the clock speeding up
-    gps_seconds = [0.0] + [3 + 10 * i + 0.1 * i * i for i in range(1, 10)]
-
-    def stamped(video_time: float) -> datetime.datetime:
-        i = int(video_time)
-        seconds = gps_seconds[i]
-        if i + 1 < len(gps_seconds):
-            seconds += (gps_seconds[i + 1] - gps_seconds[i]) * (video_time - i)
-        return START_TIME + datetime.timedelta(seconds=seconds)
+    # 10x, but the first timestamp 3 seconds early
+    gps_seconds = [0.0] + [3 + 10 * i for i in range(1, 10)]
 
     video_times = [0.0, 0.5, 2.0, 4.5, 8.0, 9.0]
     samples = [
-        _sample(sample_dir, k + 1, stamped(video_time))
+        _sample(
+            sample_dir,
+            k + 1,
+            START_TIME + datetime.timedelta(seconds=3 + 10 * video_time),
+        )
         for k, video_time in enumerate(video_times)
     ]
 
@@ -168,20 +164,18 @@ def test_samples_are_placed_by_their_own_video(tmp_path: Path):
 
 def test_samples_are_placed_along_a_clock_that_gains(tmp_path: Path):
     """
-    Interval samples are stamped along the GPS timestamps of the video. A
-    clock that gains on the video, half a second every 4 seconds, is not a
-    timelapse, and its track timed by the video placed the samples ahead
+    A clock that gains on the video, as a LabPano's runs 8/7 times as fast,
+    is no timelapse, and its track timed by the video placed the samples
+    ahead
     """
     video_path = tmp_path / "hello.mp4"
     sample_dir = tmp_path / "samples" / "hello.mp4"
     sample_dir.mkdir(parents=True)
 
-    gps_seconds = [i + 0.5 * (i // 4) for i in range(10)]
+    gps_seconds = [i * 8 / 7 for i in range(30)]
     samples = [
         _sample(
-            sample_dir,
-            k + 1,
-            START_TIME + datetime.timedelta(seconds=gps_seconds[2 * k]),
+            sample_dir, k + 1, START_TIME + datetime.timedelta(seconds=2 * k * 8 / 7)
         )
         for k in range(5)
     ]
diff --git a/tests/unit/test_gpx_video_clip.py b/tests/unit/test_gpx_video_clip.py
index 5452c38ff..149edee45 100644
--- a/tests/unit/test_gpx_video_clip.py
+++ b/tests/unit/test_gpx_video_clip.py
@@ -25,11 +25,7 @@
     SourceType,
     VideoSyncOption,
 )
-from mapillary_tools.geotag.video_extractors.gpx import (
-    GPSTimeline,
-    GPXVideoExtractor,
-    SyncMode,
-)
+from mapillary_tools.geotag.video_extractors.gpx import GPXVideoExtractor, SyncMode
 from mapillary_tools.geotag.video_extractors.native import NativeVideoExtractor
 
 _DATA = Path(__file__).resolve().parent.parent.joinpath("data")
@@ -44,13 +40,11 @@
 
 
 def _gps_video_start() -> float:
-    """The Unix time of the first frame of GPS_VIDEO, by its GPS timestamps"""
+    """The Unix time of the first frame of GPS_VIDEO, by its GPS clock"""
     points = NativeVideoExtractor(GPS_VIDEO).extract().points
     clock = GPXVideoExtractor._read_video_clock(points)
     assert clock is not None
-    timeline = GPSTimeline.read(points, clock.rate)
-    assert timeline is not None
-    return timeline.to_unix_time(0)
+    return clock.to_unix_time(0)
 
 
 def _write_gpx(path: Path, start: float, seconds: int) -> Path:
@@ -119,9 +113,8 @@ def test_by_the_start_time_is_clipped_to_the_video(self, tmp_path):
 
     def test_started_with_the_video_is_clipped(self, tmp_path):
         """
-        --interpolation_use_gpx_start_time places the track, and the GPS
-        timestamps of the video give its pace, a second per second give or
-        take their jitter
+        --interpolation_use_gpx_start_time places the track, and the GPS clock
+        gives its pace
         """
         metadata = GPXVideoExtractor(
             GPS_VIDEO,
@@ -131,7 +124,7 @@ def test_started_with_the_video_is_clipped(self, tmp_path):
         ).extract()
 
         times = _times(metadata)
-        assert times[:-1] == pytest.approx([float(t) for t in range(13)], abs=0.05)
+        assert times[:-1] == [float(t) for t in range(13)]
         assert times[-1] == pytest.approx(GPS_VIDEO_DURATION)
 
     def test_the_gpx_source_clips_it(self, tmp_path):
diff --git a/tests/unit/test_gpx_video_clock.py b/tests/unit/test_gpx_video_clock.py
index eb95bc69e..3da986532 100644
--- a/tests/unit/test_gpx_video_clock.py
+++ b/tests/unit/test_gpx_video_clock.py
@@ -69,7 +69,7 @@ def test_first_timestamp_is_anchored_at_its_own_video_time(self):
     @pytest.mark.parametrize("rate", [2.0, 12.5, 30.0])
     def test_timelapse(self, rate):
         """1s of video spans `rate` seconds of GPS time."""
-        clock = _read((i * 0.1, A_UNIX_TIME + i * 0.1 * rate) for i in range(20))
+        clock = _read((i * 0.1, A_UNIX_TIME + i * 0.1 * rate) for i in range(40))
         assert clock.rate == pytest.approx(rate)
         assert clock.to_video_time(A_UNIX_TIME + rate) == pytest.approx(1.0)
 
@@ -78,8 +78,12 @@ def test_small_rate_error_is_not_a_timelapse(self):
         clock = _read((i, A_UNIX_TIME + i * 1.2) for i in range(6))
         assert clock.rate == 1.0
 
-    def test_too_short_to_measure_a_rate(self):
-        clock = _read((i * 0.1, A_UNIX_TIME + i * 1.5) for i in range(9))
+    def test_too_short_to_tell_a_timelapse_from_jitter(self):
+        """
+        Two blocks of a GoPro, the second stamped 1.5 seconds late, measure
+        2.5x over a second of video
+        """
+        clock = _read([(0, A_UNIX_TIME), (1.001, A_UNIX_TIME + 2.5)])
         assert clock.rate == 1.0
 
     def test_block_timestamps_anchor_at_the_block_start(self):
diff --git a/tests/unit/test_gpx_video_sync.py b/tests/unit/test_gpx_video_sync.py
index 1da4d606b..e3b23723f 100644
--- a/tests/unit/test_gpx_video_sync.py
+++ b/tests/unit/test_gpx_video_sync.py
@@ -27,7 +27,6 @@
 )
 from mapillary_tools.geotag.video_extractors import gpx as gpx_extractor
 from mapillary_tools.geotag.video_extractors.gpx import (
-    GPSTimeline,
     GPXVideoExtractor,
     SyncMode,
     VideoClock,
@@ -396,10 +395,8 @@ def test_the_offset_applies_to_a_track_synced_by_the_video_gps(self, tmp_path):
             GPS_VIDEO, gpx, VideoSyncOption(), InterpolationOption(offset_time=2)
         )
 
-        # Each point is where the one 2 GPS seconds before it was: the video
-        # is looked up 2 GPS seconds further along the track
-        assert [p.time for p in shifted.points][2:] == pytest.approx(
-            [p.time for p in synced.points][:-2]
+        assert [p.time for p in shifted.points] == pytest.approx(
+            [p.time - 2 for p in synced.points]
         )
 
     def test_use_gpx_start_time_starts_the_track_with_the_video(self, tmp_path):
@@ -467,7 +464,7 @@ def test_at_the_pace_of_the_gps_clock_too(self, tmp_path, monkeypatch):
             InterpolationOption(use_gpx_start_time=True),
         )
 
-        assert metadata.points[0].time == pytest.approx(0.5)
+        assert metadata.points[0].time == 0.5
         assert metadata.points[0].get_unix_time() == _GPS_VIDEO_START.timestamp()
 
     def test_process_starts_the_track_at_time_0(self, tmp_path):
@@ -506,7 +503,7 @@ class TestProcessInterpolationOptions:
     it does when it geotags images from a GPX. It ignored them for videos.
     """
 
-    # 3.624 seconds before the GPS timestamps of GPS_VIDEO place its start
+    # 3.613 seconds before the GPS clock of GPS_VIDEO starts
     START = datetime.datetime(2019, 11, 18, 23, 44, 40, tzinfo=datetime.timezone.utc)
 
     def test_use_gpx_start_time_starts_the_track_with_a_video_with_gps(self, tmp_path):
@@ -518,8 +515,8 @@ def test_use_gpx_start_time_starts_the_track_with_a_video_with_gps(self, tmp_pat
             GPS_VIDEO, gpx, None, InterpolationOption(use_gpx_start_time=True)
         )
 
-        assert synced.points[0].time == pytest.approx(-3.624)
-        assert started.points[0].time == pytest.approx(0, abs=1e-6)
+        assert synced.points[0].time == pytest.approx(-3.613)
+        assert started.points[0].time == 0
 
     def test_the_offset_shifts_the_track_but_not_its_times(self, tmp_path):
         """
@@ -531,8 +528,8 @@ def test_the_offset_shifts_the_track_but_not_its_times(self, tmp_path):
         synced = _extract(GPS_VIDEO, gpx, None, InterpolationOption())
         shifted = _extract(GPS_VIDEO, gpx, None, InterpolationOption(offset_time=2))
 
-        assert [p.time for p in shifted.points][2:] == pytest.approx(
-            [p.time for p in synced.points][:-2]
+        assert [p.time for p in shifted.points] == pytest.approx(
+            [p.time - 2 for p in synced.points]
         )
         assert [p.get_unix_time() for p in shifted.points] == [
             p.get_unix_time() for p in synced.points
@@ -690,15 +687,6 @@ def test_the_offset_is_in_gps_seconds(self, tmp_path, monkeypatch):
                 )
             ),
         )
-        monkeypatch.setattr(
-            GPSTimeline,
-            "read",
-            classmethod(
-                lambda cls, points, rate: GPSTimeline(
-                    (0.0,), (start.timestamp(),), rate
-                )
-            ),
-        )
         gpx = _write_gpx(tmp_path / "track.gpx", seconds=30, start=start)
 
         synced = _extract(GPS_VIDEO, gpx, VideoSyncOption())
diff --git a/tests/unit/test_gps_timeline.py b/tests/unit/test_gpx_video_timestamps.py
similarity index 50%
rename from tests/unit/test_gps_timeline.py
rename to tests/unit/test_gpx_video_timestamps.py
index 9b3ed64c7..71e3ccdaa 100644
--- a/tests/unit/test_gps_timeline.py
+++ b/tests/unit/test_gpx_video_timestamps.py
@@ -4,9 +4,9 @@
 # LICENSE file in the root directory of this source tree.
 
 """
-The GPS time of a video along it, through its GPS timestamps, and the GPX
-tracks placed by it: GPX sync looks each GPX point up along it, as interval
-samples are stamped by it.
+The GPS timestamps of a video, which its GPS clock is fitted to, and the GPX
+tracks placed by that clock: a straight line, from which the timestamps of a
+camera that records in real time jitter by up to a second or more.
 """
 
 from __future__ import annotations
@@ -18,11 +18,7 @@
 import pytest
 from mapillary_tools import geo, telemetry, types
 from mapillary_tools.geotag.options import InterpolationOption, VideoSyncOption
-from mapillary_tools.geotag.video_extractors.gpx import (
-    GPSTimeline,
-    GPXVideoExtractor,
-    VideoClock,
-)
+from mapillary_tools.geotag.video_extractors.gpx import GPXVideoExtractor, VideoClock
 
 _DATA = Path(__file__).resolve().parent.parent.joinpath("data")
 
@@ -50,25 +46,20 @@ def _points(pairs: T.Iterable[tuple[float, float]]) -> list[geo.Point]:
     ]
 
 
-def _read(pairs: T.Iterable[tuple[float, float]], rate: float = 1.0):
-    timeline = GPSTimeline.read(_points(pairs), rate)
-    assert timeline is not None
+def _read(pairs: T.Iterable[tuple[float, float]]) -> list[tuple[float, float]]:
     return [
         (v, round(u - START.timestamp(), 3))
-        for v, u in zip(timeline.video_times, timeline.unix_times)
+        for v, u in GPXVideoExtractor._read_timestamps(_points(pairs))
     ]
 
 
-class TestRead:
-    def test_through_the_timestamps(self):
-        timeline = GPSTimeline.read(_points([(0, 0), (1, 1), (2, 3)]), rate=1.0)
-        assert timeline is not None
+def _clock(pairs: T.Iterable[tuple[float, float]]) -> VideoClock:
+    clock = GPXVideoExtractor._read_video_clock(_points(pairs))
+    assert clock is not None
+    return clock
 
-        assert timeline.to_unix_time(1.5) == START.timestamp() + 2
-        assert timeline.to_video_time(START.timestamp() + 2) == 1.5
-        # beyond them, at the rate
-        assert timeline.to_unix_time(3) == START.timestamp() + 4
 
+class TestReadTimestamps:
     def test_the_first_point_of_a_block(self):
         """GoPro stamps a block of points with one timestamp"""
         assert _read([(0, 0), (0.5, 0), (1, 1), (1.5, 1), (2, 2)]) == [
@@ -87,7 +78,7 @@ def test_without_a_stale_first_timestamp(self):
 
     def test_without_stale_first_timestamps_of_a_timelapse(self):
         """Those of a timelapse run more than its rate behind the rest"""
-        assert _read([(0, 0), (0.1, 3.9), (0.2, 4.9), (0.3, 5.9)], rate=10) == [
+        assert _read([(0, 0), (0.1, 3.9), (0.2, 4.9), (0.3, 5.9)]) == [
             (0.1, 3.9),
             (0.2, 4.9),
             (0.3, 5.9),
@@ -100,7 +91,6 @@ def test_with_the_steps_of_a_clock_that_gains(self):
         assert _read(pairs) == pairs
 
     def test_with_the_steps_of_a_short_timelapse(self):
-        """Over less than a second of video, too short to measure, its rate is 1"""
         pairs = [(0, 0), (0.08, 1), (0.16, 2), (0.24, 3)]
 
         assert _read(pairs) == pairs
@@ -115,11 +105,11 @@ def test_without_a_stale_first_timestamp_of_a_short_timelapse(self):
     def test_without_timestamps_out_of_order(self):
         pairs = [(0, 0), (1, 1), (2, 60), (3, 3), (4, 4), (5, 3.5), (6, 6)]
 
-        timeline = _read(pairs)
+        timestamps = _read(pairs)
 
-        assert (2, 60) not in timeline
-        assert len(timeline) == 5
-        assert [u for _, u in timeline] == sorted(u for _, u in timeline)
+        assert (2, 60) not in timestamps
+        assert len(timestamps) == 5
+        assert [u for _, u in timestamps] == sorted(u for _, u in timestamps)
 
     def test_without_a_placeholder_date(self):
         """GoPro stamps a date in 2015 until the GPS acquires the time"""
@@ -132,17 +122,78 @@ def test_none_without_timestamps(self):
         points = _points([(0, 0)])
         points[0] = geo.Point(time=0, lat=37, lon=-122, alt=None, angle=None)
 
-        assert GPSTimeline.read(points, rate=1.0) is None
+        assert GPXVideoExtractor._read_timestamps(points) == []
 
-    def test_starting_at(self):
-        timeline = GPSTimeline.read(_points([(0, 0), (1, 1), (2, 3)]), rate=1.0)
-        assert timeline is not None
 
-        started = timeline.starting_at(0.5, START.timestamp() + 100)
+# A GoPro's timestamps of blocks of 1.001 seconds of video, which jitter by
+# up to a second off the straight line through them
+JITTER = [0.0, 0.6, -0.4, 0.9, 0.1, -0.5, 0.3, 1.0, -0.2, 0.0, 0.4, -0.6, 0.2]
+GOPRO_PAIRS = [(1.001 * i, 1.001 * i + j) for i, j in enumerate(JITTER)]
 
-        assert started.to_unix_time(0.5) == pytest.approx(START.timestamp() + 100)
-        # at its pace
-        assert started.to_unix_time(2) == pytest.approx(START.timestamp() + 102.5)
+
+class TestStraightClock:
+    def test_a_camera_that_records_in_real_time(self):
+        """Not through its timestamps, which stamp 1 second as 0.1 to 2 seconds"""
+        clock = _clock(GOPRO_PAIRS)
+
+        assert clock.rate == 1.0
+        # Anchored at the median of its timestamps
+        assert clock.to_unix_time(0) == pytest.approx(START.timestamp() + 0.1)
+
+    def test_a_clock_that_gains_on_the_video(self):
+        """
+        A LabPano gains a second on the video every 7 seconds, in steps of a
+        second per half second, and its timestamps fit 8/7 GPS seconds per
+        second of video within 0.3 seconds
+        """
+        pairs = [(round(s * 7 / 8 * 2) / 2, s) for s in range(200)]
+
+        clock = _clock(pairs)
+
+        assert clock.rate == pytest.approx(8 / 7, abs=0.001)
+        for v, u in pairs:
+            assert clock.to_unix_time(v) - START.timestamp() == pytest.approx(
+                u, abs=0.3
+            )
+
+    def test_a_rate_within_a_few_percent_is_1(self):
+        """
+        A GoPro MAX whose GPS glitches measures 1.6% off 1x over 3 minutes.
+        It records in real time
+        """
+        clock = _clock((i, i * 0.984) for i in range(190))
+
+        assert clock.rate == 1.0
+
+    def test_a_rate_measured_over_a_short_clip_is_1(self):
+        """
+        Over a few seconds, a second of jitter measures a rate 15% off 1x, a
+        drift of half a second
+        """
+        clock = _clock([(0, 0), (1, 1.4), (2, 2.1), (3, 3.45)])
+
+        assert clock.rate == 1.0
+
+    def test_a_short_timelapse(self):
+        """
+        Its rate, 12.4x over less than a second of video, drifts by 11
+        seconds from 1x
+        """
+        clock = _clock((seconds / 12.4, seconds) for seconds in range(13))
+
+        assert clock.rate == pytest.approx(12.4)
+
+    def test_a_stale_first_timestamp_off_the_line(self):
+        clock = _clock([(0, -5), *GOPRO_PAIRS[1:]])
+
+        assert clock.rate == 1.0
+        assert clock.to_unix_time(0) == pytest.approx(START.timestamp() + 0.1)
+
+    def test_a_timestamp_far_off_makes_no_timelapse(self):
+        """It pulls the least-squares slope past the timelapse rate"""
+        pairs = [(i, i) for i in range(9)] + [(9, 30)]
+
+        assert _clock(pairs).rate == 1.0
 
 
 def _gpx(path: Path, seconds: T.Iterable[float]) -> Path:
@@ -161,29 +212,14 @@ def _gpx(path: Path, seconds: T.Iterable[float]) -> Path:
 
 
 class TestGPXPlacement:
-    """GPX sync places each GPX point at the video time of its GPS time"""
-
-    # Over the 12 seconds of the video, the clock gains 2 seconds
-    PAIRS = [
-        (0, 0),
-        (1, 1),
-        (2, 2),
-        (3, 3),
-        (3.5, 4),
-        (4.5, 5),
-        (5.5, 6),
-        (6.5, 7),
-        (7, 8),
-        (8, 9),
-        (9, 10),
-        (10, 11),
-        (11, 12),
-        (12, 13),
-    ]
+    """
+    GPX sync places each GPX point at the video time of its GPS time by the
+    straight clock of the video, not through the timestamps of the video,
+    whose jitter is not that of the GPX
+    """
 
-    @pytest.fixture
-    def video_gps(self, monkeypatch):
-        self.mock_video_gps(monkeypatch, self.PAIRS)
+    # The GPX records a point every second
+    GPX_SECONDS = [float(s) for s in range(13)]
 
     @staticmethod
     def mock_video_gps(
@@ -202,55 +238,55 @@ def mock_video_gps(
 
     def _extract(self, tmp_path: Path, **kwargs) -> dict[float, float]:
         """GPS seconds from START of each GPX point, to its video time"""
-        gpx = _gpx(tmp_path / "track.gpx", [s for _, s in self.PAIRS])
+        gpx = _gpx(tmp_path / "track.gpx", self.GPX_SECONDS)
         metadata = GPXVideoExtractor(VIDEO, gpx, **kwargs).extract()
         return {
             round(T.cast(float, p.get_unix_time()) - START.timestamp(), 3): p.time
             for p in metadata.points
         }
 
-    def test_at_the_video_time_of_its_gps_time(self, tmp_path, video_gps):
-        """
-        A straight clock, anchored at the median of the timestamps, put the
-        points up to a second off
-        """
-        placed = self._extract(tmp_path, video_sync=VideoSyncOption())
+    @pytest.mark.parametrize("video_sync", [VideoSyncOption(), None])
+    def test_by_the_straight_clock(self, tmp_path, monkeypatch, video_sync):
+        """In distance sampling and in process"""
+        self.mock_video_gps(monkeypatch, GOPRO_PAIRS)
 
-        for video_time, seconds in self.PAIRS:
-            assert placed[seconds] == pytest.approx(video_time)
+        placed = self._extract(tmp_path, video_sync=video_sync)
 
-    def test_in_process_too(self, tmp_path, video_gps):
-        placed = self._extract(tmp_path)
+        # A second of video per second of the GPX, from the median of the
+        # timestamps of the video, 0.1 seconds after START
+        for seconds in self.GPX_SECONDS:
+            assert placed[seconds] == pytest.approx(seconds - 0.1)
 
-        for video_time, seconds in self.PAIRS:
-            assert placed[seconds] == pytest.approx(video_time)
-
-    def test_without_a_stale_first_timestamp(self, tmp_path, monkeypatch):
-        self.mock_video_gps(monkeypatch, [(0, -5), *self.PAIRS[1:]])
+    def test_at_the_pace_of_a_clock_that_gains(self, tmp_path, monkeypatch):
+        # Over 30 seconds, as 12 are too few to tell 8/7 from 1x (by 1.7 s)
+        self.mock_video_gps(monkeypatch, [(i, i * 8 / 7) for i in range(30)])
+        self.GPX_SECONDS = [float(s) for s in range(15)]
 
         placed = self._extract(tmp_path, video_sync=VideoSyncOption())
 
-        # From the second timestamp back at the clock's rate
-        assert placed[0] == pytest.approx(0)
-        assert placed[1] == pytest.approx(1)
+        for seconds in self.GPX_SECONDS:
+            assert placed[seconds] == pytest.approx(seconds * 7 / 8)
 
-    def test_the_offset_in_gps_seconds(self, tmp_path, video_gps):
+    def test_the_offset_in_gps_seconds(self, tmp_path, monkeypatch):
         """
         The video is looked up 1 GPS second further along the track, whose
         points keep their times in process
         """
+        self.mock_video_gps(monkeypatch, GOPRO_PAIRS)
+
         placed = self._extract(
             tmp_path, interpolation=InterpolationOption(offset_time=1)
         )
 
-        for (video_time, _), (_, seconds) in zip(self.PAIRS, self.PAIRS[1:]):
-            assert placed[seconds] == pytest.approx(video_time)
+        for seconds in self.GPX_SECONDS:
+            assert placed[seconds] == pytest.approx(seconds - 0.1 - 1)
 
-    def test_started_with_the_video_at_the_pace_of_the_timestamps(
+    def test_started_with_the_video_at_the_pace_of_the_clock(
         self, tmp_path, monkeypatch
     ):
-        # The timestamps of the video 100 seconds before the GPX
-        self.mock_video_gps(monkeypatch, [(v, s - 100) for v, s in self.PAIRS])
+        # The timestamps of the video 100 seconds before the GPX, 8/7 times as
+        # fast as the video
+        self.mock_video_gps(monkeypatch, [(i, i * 8 / 7 - 100) for i in range(30)])
 
         placed = self._extract(
             tmp_path,
@@ -258,18 +294,13 @@ def test_started_with_the_video_at_the_pace_of_the_timestamps(
             interpolation=InterpolationOption(use_gpx_start_time=True),
         )
 
-        for video_time, seconds in self.PAIRS:
-            assert placed[seconds] == pytest.approx(video_time)
+        for seconds in self.GPX_SECONDS:
+            assert placed[seconds] == pytest.approx(seconds * 7 / 8)
 
     def test_gps_rejected_as_noise_by_its_clock(self, tmp_path, monkeypatch):
-        """Which gives GPX sync only its clock"""
-        self.mock_video_gps(monkeypatch, self.PAIRS, noisy=True)
-        clock = GPXVideoExtractor._read_video_clock(_points(self.PAIRS))
-        assert isinstance(clock, VideoClock)
+        self.mock_video_gps(monkeypatch, GOPRO_PAIRS, noisy=True)
 
         placed = self._extract(tmp_path, video_sync=VideoSyncOption())
 
-        for _, seconds in self.PAIRS:
-            assert placed[seconds] == pytest.approx(
-                clock.to_video_time(START.timestamp() + seconds)
-            )
+        for seconds in self.GPX_SECONDS:
+            assert placed[seconds] == pytest.approx(seconds - 0.1)
diff --git a/tests/unit/test_sample_video.py b/tests/unit/test_sample_video.py
index 3f6d30df9..ef29de517 100644
--- a/tests/unit/test_sample_video.py
+++ b/tests/unit/test_sample_video.py
@@ -323,50 +323,60 @@ def test_capture_times_follow_the_gps_clock(
         )
         assert "--video_duration_ratio" not in caplog.text
 
-    def test_capture_times_follow_the_gps_timestamps(
+    def _capture_times(self, samples: T.Sequence[Path]) -> list[float]:
+        """In seconds from GPS_START_TIME"""
+        return [
+            round(
+                (
+                    exif_read.ExifRead(sample).extract_capture_time()
+                    - self.GPS_START_TIME
+                ).total_seconds(),
+                3,
+            )
+            for sample in sorted(samples)
+        ]
+
+    def test_capture_times_follow_the_gps_clock_without_a_stale_timestamp(
         self, tmpdir, setup_mock, monkeypatch
     ):
         """
-        Not one rate: the GPS clock of a timelapse drifts from it, and distance
-        samples are stamped from the timestamps. The geotagging stage places
-        both kinds of samples along a track timed by them
+        The first GPS timestamp of a GoPro MAX timelapse can be seconds early,
+        and starts neither the clock nor the samples
         """
-        self._mock_telemetry(monkeypatch, lambda i: 10 * i + 0.1 * i * i)
+        self._mock_telemetry(monkeypatch, lambda i: -10 if i == 0 else 10 * i)
 
-        samples = sorted(self._sample(tmpdir))
+        capture_times = self._capture_times(self._sample(tmpdir))
 
-        assert len(samples) > 2
-        for idx, sample in enumerate(samples):
-            video_time = 2 * idx
-            assert exif_read.ExifRead(
-                sample
-            ).extract_capture_time() == self.GPS_START_TIME + datetime.timedelta(
-                seconds=10 * video_time + 0.1 * video_time * video_time
-            )
+        assert len(capture_times) > 2
+        assert capture_times == [20.0 * idx for idx in range(len(capture_times))]
 
-    def test_a_normal_video_follows_its_gps_timestamps(
+    def test_a_normal_video_follows_its_gps_clock(
         self, tmpdir, setup_mock, monkeypatch
     ):
         """
-        Not one second per second from the median of its first timestamps: the
-        first can be stale, and the clock of some cameras gains on the video
+        A second per second from the median of its timestamps, not through
+        them: the first can be stale, and the others jitter
         """
-        # The first timestamp 5 seconds stale, and half a second gained every
-        # 4 seconds
-        self._mock_telemetry(
-            monkeypatch, lambda i: -5 if i == 0 else i + 0.5 * (i // 4)
-        )
+        # The first timestamp 5 seconds stale, and the others half a second off
+        # the line through them
+        jitter = [0.0, 0.5, -0.5, 0.0]
+        self._mock_telemetry(monkeypatch, lambda i: -5 if i == 0 else i + jitter[i % 4])
 
-        samples = sorted(self._sample(tmpdir))
+        capture_times = self._capture_times(self._sample(tmpdir))
 
-        assert len(samples) > 2
-        for idx, sample in enumerate(samples):
-            video_time = 2 * idx
-            assert exif_read.ExifRead(
-                sample
-            ).extract_capture_time() == self.GPS_START_TIME + datetime.timedelta(
-                seconds=video_time + 0.5 * (video_time // 4)
-            )
+        assert len(capture_times) > 2
+        assert capture_times == [2.0 * idx for idx in range(len(capture_times))]
+
+    def test_a_clock_that_gains_on_the_video(self, tmpdir, setup_mock, monkeypatch):
+        """A LabPano's runs 8/7 times as fast as the video"""
+        self._mock_telemetry(monkeypatch, lambda i: i * 8 / 7)
+
+        capture_times = self._capture_times(self._sample(tmpdir))
+
+        assert len(capture_times) > 2
+        assert capture_times == pytest.approx(
+            [2 * idx * 8 / 7 for idx in range(len(capture_times))], abs=0.001
+        )
 
     def test_from_the_given_start_time(self, tmpdir, setup_mock, timelapse_telemetry):
         video_start_time = "2020_08_10_14_37_05_023"

From 25ff0dae0ff4ffa41f0a2bb9a9ebb5db04e1ef7b Mon Sep 17 00:00:00 2001
From: Caglar Pir <caglarp@meta.com>
Date: Fri, 23 Oct 2026 10:53:56 +0200
Subject: [PATCH 2/5] Fail files that no geotag source is given, and those none
 can read

Two ways a file given to process could be left out of the results, as
if it had not been there, with exit 0:

#875 left a video out when --filetypes named types of video (gopro,
blackvue, camm) and none of the geotag sources given could read videos:
the type of a video is known only once it is read, so it might not be of
any of them. That brought back the silent drop that #868 fixed. On a
GoPro video, `process VIDEO --filetypes gopro --geotag_source exif`
exited 0 with an empty description.

A file could also be given to no source at all, when the filetypes of
every source leave it out. `--geotag_source '{"source": "native",
"filetypes": ["image"]}'` gave the videos of a folder to no source, and a
source limited to GoPro videos its images. --filetypes limits the
filetypes of every source further: `--filetypes gopro
--video_geotag_source '{"source": "native", "filetypes": ["blackvue"]}'`
gave a GoPro video to no source.

Fail such a file, as #868 fails a video that no source can read: "No
geotag source is given for this video: the geotag source native is
limited to other file types", or "--filetypes gopro leaves no geotag
source for this video: the geotag sources native, exiftool_runtime are
limited to other file types". A file of a type that --filetypes leaves
out is still left out. For a video, which --filetypes names by the type
of its GPS, that is told as the native reader does while geotagging:
given the types asked for, it recognizes one of them in the video, or
none. A video of none of them is left out, as #875 leaves out the videos
that a source found to be of other types, and any other is failed. No
video is read for it without --filetypes or with --filetypes video.

Checked process on a folder of a GoPro, a CAMM, a BlackVue and an
unrecognized video and an image, and on the GoPro video alone: with no
--filetypes, and with gopro, camm, blackvue, video, image, image,gopro,
gopro,camm,blackvue and camm,video; each with the default sources, exif,
native, gpx, --video_geotag_source native, exif and --video_geotag_source
native, --video_geotag_source gpx, and exif and a native source limited
to camm (144 runs). Only the 13 runs in which exif was the only source
given videos change: the videos of the types asked for are failed, and
the others are still left out. Nor do the flows whose sources are
limited by design change: process with the default sources, with exif,
with --video_geotag_source native, gpx or exiftool_runtime alone, with
exiftool_runtime, exiftool_xml, gpx or NMEA, with the image-only gopro,
camm and blackvue sources on sampled frames, alone or beside their
videos, and video_process with the default sources, exif,
--video_geotag_source native, gpx, exiftool_xml and the gopro source.
video_process with only a gpx source limited to videos, whose frames no
source geotagged, now fails them rather than exit 0 with an empty
description.
---
 mapillary_tools/geotag/factory.py   | 125 ++++++++++++++++++++++++++--
 tests/integration/test_process.py   |  61 ++++++++++++++
 tests/unit/test_geotag_filetypes.py | 122 +++++++++++++++++++++++++--
 3 files changed, 294 insertions(+), 14 deletions(-)

diff --git a/mapillary_tools/geotag/factory.py b/mapillary_tools/geotag/factory.py
index bb7d20b3b..de3fb2d14 100644
--- a/mapillary_tools/geotag/factory.py
+++ b/mapillary_tools/geotag/factory.py
@@ -197,6 +197,9 @@ def process(
     # those sources, to report if no other source geotags them or fails to
     unread_videos: dict[Path, list[SourceType]] = {}
 
+    # Paths let through to any source
+    handed_paths: set[Path] = set()
+
     for option in options:
         if option.source in EXTERNAL_GPS_SOURCES:
             option_paths = reprocessable_paths
@@ -215,6 +218,7 @@ def process(
         image_videos, video_paths = _filter_images_and_videos(
             option_paths, option.filetypes
         )
+        handed_paths.update(image_videos, video_paths)
 
         if image_videos:
             image_geotag = _build_image_geotag(option)
@@ -291,18 +295,125 @@ def process(
             break
 
     final_metadatas.extend(pending_errors.values())
-    # Limited to some types of video, a video that no source read may not be
-    # of any of them, and is left out as the videos found to be of other types
-    if video_types is None:
-        final_metadatas.extend(
-            _describe_unread_video(path, sources)
-            for path, sources in unread_videos.items()
-            if path in reprocessable_paths and path not in pending_errors
+
+    unread_paths = [
+        path
+        for path in unread_videos
+        if path in reprocessable_paths and path not in pending_errors
+    ]
+
+    # Files that no source was let through, as the filetypes of every source
+    # leave them out (e.g. sources for images only, or a source for BlackVue
+    # videos with --filetypes gopro), but those that --filetypes leaves out
+    sourceless_images, sourceless_videos = _filter_images_and_videos(
+        sorted(reprocessable_paths - handed_paths), filetypes
+    )
+
+    if video_types is not None and (unread_paths or sourceless_videos):
+        # Limited to some types of video, a video that no source read may not
+        # be of any of them. Those of other types are left out, as the videos
+        # found to be of other types
+        kept_paths = set(
+            _videos_not_of_other_types(
+                unread_paths + sourceless_videos,
+                video_types,
+                # The same for every option (see process_geotag_properties)
+                num_processes=next(iter(options)).num_processes,
+            )
         )
+        unread_paths = [path for path in unread_paths if path in kept_paths]
+        sourceless_videos = [path for path in sourceless_videos if path in kept_paths]
+
+    final_metadatas.extend(
+        _describe_unread_video(path, unread_videos[path]) for path in unread_paths
+    )
+    final_metadatas.extend(
+        _describe_sourceless_file(path, options, filetypes)
+        for path in sourceless_images + sourceless_videos
+    )
 
     return final_metadatas
 
 
+def _videos_not_of_other_types(
+    video_paths: T.Sequence[Path],
+    video_types: set[types.FileType],
+    num_processes: int | None = None,
+) -> list[Path]:
+    """
+    The videos of **video_paths** that are of the types **video_types**, or of
+    a type that cannot be told: all but those in which the native reader, given
+    those types, recognizes none of them, as process() tells while geotagging
+    (see _is_of_other_type)
+    """
+    LOG.info(
+        f"==> Reading the type of {len(video_paths)} videos that no source can geotag..."
+    )
+    native = SourceOption(
+        SourceType.NATIVE, filetypes=video_types, num_processes=num_processes
+    )
+    video_geotag = geotag_videos_from_video.GeotagVideosFromVideo(
+        filetypes=native.filetypes, num_processes=native.num_processes
+    )
+    other_types = {
+        metadata.filename
+        for metadata in video_geotag.to_description(video_paths)
+        if _is_of_other_type(metadata, native, video_types)
+    }
+    return [path for path in video_paths if path not in other_types]
+
+
+def _describe_sourceless_file(
+    path: Path,
+    options: T.Iterable[SourceOption],
+    filetypes: set[types.FileType] | None,
+) -> types.ErrorMetadata:
+    """
+    Describe a file that no source of **options** was let through, limited to
+    --filetypes **filetypes**, rather than leave it out of the results as if it
+    had not been there
+
+    >>> video_only = SourceOption(SourceType.NATIVE, filetypes={types.FileType.VIDEO})
+    >>> _describe_sourceless_file(Path("i.jpg"), [video_only], None).error
+    MapillaryGeoTaggingError('No geotag source is given for this image: the geotag source native is limited to other file types')
+    >>> # For BlackVue videos, limited to --filetypes gopro
+    >>> blackvue_only = SourceOption(SourceType.NATIVE, filetypes=set())
+    >>> _describe_sourceless_file(Path("v.mp4"), [blackvue_only], {types.FileType.GOPRO}).error
+    MapillaryVideoGPSNotFoundError('--filetypes gopro leaves no geotag source for this video: the geotag source native is limited to other file types')
+    >>> images_only = [
+    ...     SourceOption(SourceType.NATIVE, filetypes={types.FileType.IMAGE}),
+    ...     SourceOption(SourceType.EXIFTOOL_RUNTIME, filetypes={types.FileType.IMAGE}),
+    ... ]
+    >>> filetypes = {types.FileType.IMAGE, types.FileType.GOPRO}
+    >>> _describe_sourceless_file(Path("v.mp4"), images_only, filetypes).error
+    MapillaryVideoGPSNotFoundError('--filetypes gopro,image leaves no geotag source for this video: the geotag sources native, exiftool_runtime are limited to other file types')
+    """
+    kind = "image" if utils.is_image_file(path) else "video"
+    if filetypes is None:
+        no_source = f"No geotag source is given for this {kind}"
+    else:
+        asked_for = ",".join(sorted(filetype.value for filetype in filetypes))
+        no_source = f"--filetypes {asked_for} leaves no geotag source for this {kind}"
+    names = list(dict.fromkeys(option.source.value for option in options))
+    sources = (
+        f"the geotag sources {', '.join(names)} are"
+        if len(names) > 1
+        else f"the geotag source {names[0]} is"
+    )
+    message = f"{no_source}: {sources} limited to other file types"
+    if kind == "image":
+        return types.describe_error_metadata(
+            exceptions.MapillaryGeoTaggingError(message),
+            path,
+            filetype=types.FileType.IMAGE,
+        )
+    return types.describe_error_metadata(
+        exceptions.MapillaryVideoGPSNotFoundError(message),
+        path,
+        filetype=types.FileType.VIDEO,
+    )
+
+
 def _describe_unread_video(
     video_path: Path, sources: T.Sequence[SourceType]
 ) -> types.ErrorMetadata:
diff --git a/tests/integration/test_process.py b/tests/integration/test_process.py
index 46385de91..1027eaed4 100644
--- a/tests/integration/test_process.py
+++ b/tests/integration/test_process.py
@@ -663,6 +663,67 @@ def test_process_filetypes_of_videos(setup_data: py.path.local):
     ]
 
 
+def test_process_filetypes_of_videos_no_source_can_read(setup_data: py.path.local):
+    """
+    A video of a type asked for, given only sources that cannot geotag videos,
+    is failed as without --filetypes. It was left out of the results
+    """
+    videos = [
+        str(setup_data.join("gopro_data").join("max-360mode.mp4")),
+        str(setup_data.join("videos").join("sample-5s.mp4")),
+    ]
+    descs = run_process_for_descs(
+        ["--filetypes=gopro", "--geotag_source=exif", *videos]
+    )
+    assert [(Path(d["filename"]).name, d["error"]["message"]) for d in descs] == [
+        ("max-360mode.mp4", "The geotag source exif cannot geotag videos")
+    ]
+
+    assert [] == run_process_for_descs(
+        ["--filetypes=blackvue", "--geotag_source=exif", *videos]
+    )
+
+
+def test_process_filetypes_no_source_is_given(setup_data: py.path.local):
+    """
+    The filetypes of every source, limited to --filetypes if given, can leave
+    out a file, which --filetypes lets in. It was left out of the results
+    """
+    videos = [
+        str(setup_data.join("gopro_data").join("max-360mode.mp4")),
+        str(setup_data.join("videos").join("sample-5s.mp4")),
+    ]
+    image_source = ['--geotag_source={"source": "native", "filetypes": ["image"]}']
+    descs = run_process_for_descs([*image_source, *videos])
+    assert sorted((Path(d["filename"]).name, d["error"]["message"]) for d in descs) == [
+        (
+            name,
+            "No geotag source is given for this video: the geotag source native "
+            "is limited to other file types",
+        )
+        for name in ["max-360mode.mp4", "sample-5s.mp4"]
+    ]
+
+    blackvue_source = [
+        "--video_geotag_source",
+        '{"source": "native", "filetypes": ["blackvue"]}',
+    ]
+    descs = run_process_for_descs(["--filetypes=gopro", *blackvue_source, *videos])
+    assert [(Path(d["filename"]).name, d["error"]["message"]) for d in descs] == [
+        (
+            "max-360mode.mp4",
+            "--filetypes gopro leaves no geotag source for this video: the geotag "
+            "sources native, exiftool_runtime are limited to other file types",
+        )
+    ]
+
+    image_dir = setup_data.join("images")
+    video_source = ['--geotag_source={"source": "native", "filetypes": ["video"]}']
+    descs = run_process_for_descs(["--filetypes=image", *video_source, str(image_dir)])
+    assert descs
+    assert {d["error"]["type"] for d in descs} == {"MapillaryGeoTaggingError"}
+
+
 def test_process_video_geotag_source_with_gpx_specified(setup_data: py.path.local):
     video_path = setup_data.join("videos").join("sample-5s.mp4")
     gpx_file = setup_data.join("gpx").join("sf_30km_h.gpx")
diff --git a/tests/unit/test_geotag_filetypes.py b/tests/unit/test_geotag_filetypes.py
index 34629c0f9..5310fc1c9 100644
--- a/tests/unit/test_geotag_filetypes.py
+++ b/tests/unit/test_geotag_filetypes.py
@@ -188,18 +188,126 @@ def test_the_filetypes_of_a_source_leave_the_video_to_the_next(
         assert isinstance(result, types.VideoMetadata)
         assert called == DEFAULT_CHAIN
 
-    def test_video_that_no_source_can_read_is_left_out(self, monkeypatch):
+    @pytest.mark.parametrize(
+        "filetypes", [None, GOPRO, {types.FileType.GOPRO, types.FileType.BLACKVUE}]
+    )
+    def test_video_of_a_type_asked_for_that_no_source_can_read_is_reported(
+        self, filetypes
+    ):
         """
-        Its type is not known without reading it, so it may not be of any of the
-        types asked for
+        It was left out, as if it had not been there, when --filetypes was
+        given. Its type is read to tell, by the native reader
         """
-        results, _ = _run_chain(monkeypatch, _options(SourceType.EXIF), {}, GOPRO)
+        video = DATA / "gopro_data" / "max-360mode.mp4"
+        [result] = _process_without_stubs([video], _options(SourceType.EXIF), filetypes)
+        assert isinstance(result, types.ErrorMetadata)
+        assert result.filename == video
+        assert "cannot geotag videos" in str(result.error)
+
+    @pytest.mark.parametrize(
+        ("video", "filetypes"),
+        [
+            (DATA / "videos" / "sample-5s.mp4", GOPRO),
+            (DATA / "gopro_data" / "max-360mode.mp4", {types.FileType.BLACKVUE}),
+        ],
+    )
+    def test_video_of_another_type_that_no_source_can_read_is_left_out(
+        self, video, filetypes
+    ):
+        results = _process_without_stubs([video], _options(SourceType.EXIF), filetypes)
         assert results == []
 
-        results, _ = _run_chain(monkeypatch, _options(SourceType.EXIF), {}, None)
-        [result] = results
+
+def _blackvue_source_and_default_image_sources() -> list[SourceOption]:
+    """
+    --video_geotag_source '{"source": "native", "filetypes": ["blackvue"]}' and
+    the default sources for images, as process_geotag_properties() makes them
+    """
+    return [
+        SourceOption(SourceType.NATIVE, filetypes={types.FileType.BLACKVUE}),
+        SourceOption(SourceType.NATIVE, filetypes={types.FileType.IMAGE}),
+        SourceOption(SourceType.EXIFTOOL_RUNTIME, filetypes={types.FileType.IMAGE}),
+    ]
+
+
+class TestFilesNoSourceIsGiven:
+    """
+    The filetypes of every source, limited to --filetypes if given, can leave
+    out a file, which --filetypes lets in. It was left out, as if it had not
+    been there
+    """
+
+    def test_video_of_a_type_asked_for_is_reported(self):
+        video = DATA / "gopro_data" / "max-360mode.mp4"
+        [result] = _process_without_stubs(
+            [video], _blackvue_source_and_default_image_sources(), GOPRO
+        )
         assert isinstance(result, types.ErrorMetadata)
-        assert "cannot geotag videos" in str(result.error)
+        assert isinstance(result.error, exceptions.MapillaryVideoGPSNotFoundError)
+        assert result.filename == video
+        assert str(result.error) == (
+            "--filetypes gopro leaves no geotag source for this video: the geotag "
+            "sources native, exiftool_runtime are limited to other file types"
+        )
+
+    def test_video_of_another_type_is_left_out(self):
+        video = DATA / "videos" / "sample-5s.mp4"
+        results = _process_without_stubs(
+            [video], _blackvue_source_and_default_image_sources(), GOPRO
+        )
+        assert results == []
+
+    def test_any_video_with_filetypes_video(self):
+        video = DATA / "videos" / "sample-5s.mp4"
+        [result] = _process_without_stubs(
+            [video],
+            [SourceOption(SourceType.EXIF, filetypes={types.FileType.IMAGE})],
+            {types.FileType.VIDEO},
+        )
+        assert isinstance(result, types.ErrorMetadata)
+        assert str(result.error).startswith(
+            "--filetypes video leaves no geotag source for this video"
+        )
+
+    def test_image(self):
+        image = DATA / "images" / "DSC00001.JPG"
+        options = [SourceOption(SourceType.NATIVE, filetypes={types.FileType.VIDEO})]
+        [result] = _process_without_stubs([image], options, {types.FileType.IMAGE})
+        assert isinstance(result, types.ErrorMetadata)
+        assert isinstance(result.error, exceptions.MapillaryGeoTaggingError)
+        assert result.filetype is types.FileType.IMAGE
+
+    @pytest.mark.parametrize(
+        ("path", "source_filetype", "kind"),
+        [
+            (DATA / "images" / "DSC00001.JPG", types.FileType.VIDEO, "image"),
+            (DATA / "videos" / "sample-5s.mp4", types.FileType.IMAGE, "video"),
+        ],
+    )
+    def test_without_filetypes(self, path, source_filetype, kind):
+        """
+        Left out by the filetypes of the sources alone. Without --filetypes no
+        type is left out, so a video is reported without reading its type
+        """
+        options = [SourceOption(SourceType.NATIVE, filetypes={source_filetype})]
+        [result] = _process_without_stubs([path], options, None)
+        assert isinstance(result, types.ErrorMetadata)
+        assert str(result.error) == (
+            f"No geotag source is given for this {kind}: the geotag source native "
+            "is limited to other file types"
+        )
+
+
+def _process_without_stubs(
+    paths: T.Sequence[Path],
+    options: T.Sequence[SourceOption],
+    filetypes: set[types.FileType] | None,
+) -> list[types.MetadataOrError]:
+    """factory.process() as process_geotag_properties() calls it, in this process"""
+    for option in options:
+        option.filetypes = types.combine_filetype_filters(option.filetypes, filetypes)
+        option.num_processes = 0
+    return factory.process(paths, options, filetypes)
 
 
 class TestNativeVideoExtractor:

From 25f65181400770f62f760fe429373d12be71af82 Mon Sep 17 00:00:00 2001
From: Caglar Pir <caglarp@meta.com>
Date: Fri, 23 Oct 2026 10:56:21 +0200
Subject: [PATCH 3/5] Read videos by the --video_geotag_source names the README
 documents

The README documents video, camm, gopro and blackvue as values of
--video_geotag_source, and its first video example is
`process --video_geotag_source video VIDEO_DIR/`. From v0.11 to v0.13
they read the video's own GPS: video in any format, the others in one
format each. Since v0.14, video is not a source name, and the others are
the legacy sources that geotag images from videos, which cannot read a
video. In v0.14.7 the example failed with a ValueError traceback, and
the others left the videos out of the description without a word; now
video is rejected as an unknown source (exit 2), and the others fail
every video (exit 6).

As a --video_geotag_source, video is now the native source, and camm,
gopro and blackvue (and the gopro_videos and blackvue_videos aliases)
the native source limited to the videos of their type, as before v0.14.
A video of another type is reported as having no GPS, as v0.13 reported
it. video_process samples by them too, where it fell back to the video's
own GPS of any type without a word. --geotag_source keeps these names as
they are: video is not one of them, and the others geotag images from
videos. An unknown --video_geotag_source lists video among the aliases.

On a GoPro, a CAMM and a BlackVue video, video gives the descriptions of
native, and each of camm, gopro and blackvue gives them for the videos
of its type. The README lists native, which it did not, with video as
its other name.
---
 README.md                              |  5 +-
 mapillary_tools/geotag/factory.py      | 67 +++++++++++++++++++++-----
 mapillary_tools/geotag/options.py      |  6 +++
 tests/integration/test_process.py      | 22 +++++++++
 tests/unit/test_parse_source_option.py | 64 +++++++++++++++++++++++-
 5 files changed, 149 insertions(+), 15 deletions(-)

diff --git a/README.md b/README.md
index dc1534441..b702a5a6e 100644
--- a/README.md
+++ b/README.md
@@ -414,7 +414,7 @@ The new video processing is triggered with the `--video_geotag_source SOURCE` op
 In this case, each source will be tried in turn, until one returns good quality data.
 
 `SOURCE` can be:
-1. the plain name of the source - one of `video, camm, gopro, blackvue, gpx, nmea, exiftool_xml, exiftool_runtime`
+1. the plain name of the source - one of `native, video, camm, gopro, blackvue, gpx, nmea, exiftool_xml, exiftool_runtime`
 2. a JSON object that includes optional parameters
 ```json5
 {
@@ -430,7 +430,8 @@ PATTERN specifies how the data source file is named, starting from the video fil
 
 Supported sources and their default pattern are:
 
-* `video`: parse the video, in order, as `camm, gopro, blackvue`. Pattern: `%f`
+* `native`, or `video`: parse the video looking for geolocation in any format that mapillary_tools reads: GoPro, CAMM,
+BlackVue and others. Pattern: `%f`
 * `camm`: parse the video looking for a CAMM track. Pattern: `%f`
 * `gopro`: parse the video looking for geolocation in GoPro format. Pattern: `%f`
 * `blackvue`: parse the video looking for geolocation in BlackVue format. Pattern: `%f`
diff --git a/mapillary_tools/geotag/factory.py b/mapillary_tools/geotag/factory.py
index de3fb2d14..28ea3dd0e 100644
--- a/mapillary_tools/geotag/factory.py
+++ b/mapillary_tools/geotag/factory.py
@@ -31,6 +31,7 @@
     SourceOption,
     SourcePathOption,
     SourceType,
+    VIDEO_SOURCE_TYPE_ALIAS,
 )
 
 
@@ -38,12 +39,20 @@
 
 _ALL_VIDEO_TYPES = {types.FileType.VIDEO, *types.NATIVE_VIDEO_FILETYPES}
 
+# As a --video_geotag_source, each of the legacy sources that geotag images from
+# videos reads the GPS of the videos of its type, as it did before v0.14
+_VIDEO_TYPE_OF_LEGACY_SOURCE = {
+    SourceType.GOPRO: types.FileType.GOPRO,
+    SourceType.BLACKVUE: types.FileType.BLACKVUE,
+    SourceType.CAMM: types.FileType.CAMM,
+}
+
 # Sources that read a GPS track from outside the video file, as opposed to
 # re-reading the telemetry embedded in it
 EXTERNAL_GPS_SOURCES = frozenset({SourceType.GPX, SourceType.NMEA})
 
 
-def parse_source_option(source: str) -> list[SourceOption]:
+def parse_source_option(source: str, video: bool = False) -> list[SourceOption]:
     """
     Given a source string, parse it into a list of GeotagOptions objects.
 
@@ -53,13 +62,17 @@ def parse_source_option(source: str) -> list[SourceOption]:
         "exif,gpx" -> [SourceOption(SourceType.EXIF), SourceOption(SourceType.GPX)]
         '{"source": "gpx"}' -> [SourceOption(SourceType.GPX)]
 
+    A --video_geotag_source (**video**) takes the names of
+    VIDEO_SOURCE_TYPE_ALIAS too.
+
     Raise MapillaryBadParameterError for an unknown source type, and for a
     JSON object that does not match SourceOptionSchema.
     """
+    aliases = {**SOURCE_TYPE_ALIAS, **VIDEO_SOURCE_TYPE_ALIAS} if video else None
 
     try:
-        source_type = SourceType(SOURCE_TYPE_ALIAS.get(source, source))
-    except ValueError:
+        source_type = _parse_source_type(source, aliases)
+    except exceptions.MapillaryBadParameterError:
         pass
     else:
         return [SourceOption(source_type)]
@@ -69,6 +82,10 @@ def parse_source_option(source: str) -> list[SourceOption]:
     except json.JSONDecodeError:
         pass
     else:
+        if aliases and isinstance(payload, dict):
+            name = payload.get("source")
+            if isinstance(name, str) and name in VIDEO_SOURCE_TYPE_ALIAS:
+                payload = {**payload, "source": VIDEO_SOURCE_TYPE_ALIAS[name].value}
         try:
             return [SourceOption.from_dict(payload)]
         except jsonschema.ValidationError as ex:
@@ -78,17 +95,21 @@ def parse_source_option(source: str) -> list[SourceOption]:
 
     sources = source.split(",")
 
-    return [SourceOption(_parse_source_type(s)) for s in sources]
+    return [SourceOption(_parse_source_type(s, aliases)) for s in sources]
 
 
-def _parse_source_type(source: str) -> SourceType:
+def _parse_source_type(
+    source: str, aliases: T.Mapping[str, SourceType] | None = None
+) -> SourceType:
+    if aliases is None:
+        aliases = SOURCE_TYPE_ALIAS
     try:
-        return SourceType(SOURCE_TYPE_ALIAS.get(source, source))
+        return SourceType(aliases.get(source, source))
     except ValueError:
         raise exceptions.MapillaryBadParameterError(
             f"Invalid geotag source {source!r}. Supported source types: "
             f"{', '.join(s.value for s in SourceType)} "
-            f"(aliases: {', '.join(SOURCE_TYPE_ALIAS)})"
+            f"(aliases: {', '.join(aliases)})"
         ) from None
 
 
@@ -109,11 +130,8 @@ def parse_source_options(
         )
 
     for s in video_geotag_source:
-        for video_option in parse_source_option(s):
-            video_option.filetypes = types.combine_filetype_filters(
-                video_option.filetypes, {types.FileType.VIDEO}
-            )
-            parsed_options.append(video_option)
+        for video_option in parse_source_option(s, video=True):
+            parsed_options.append(_as_video_source(video_option))
 
     for s in geotag_source:
         parsed_options.extend(parse_source_option(s))
@@ -137,6 +155,31 @@ def parse_source_options(
     return parsed_options
 
 
+def _as_video_source(option: SourceOption) -> SourceOption:
+    """
+    Limit a --video_geotag_source option to videos. The legacy gopro, blackvue
+    and camm sources, which otherwise geotag images from videos, read the
+    video's own GPS as the native source does, from the videos of their type
+
+    >>> option = _as_video_source(SourceOption(SourceType.GOPRO))
+    >>> option.source, option.filetypes
+    (<SourceType.NATIVE: 'native'>, {<FileType.GOPRO: 'gopro'>})
+    >>> option = _as_video_source(SourceOption(SourceType.GPX))
+    >>> option.source, option.filetypes
+    (<SourceType.GPX: 'gpx'>, {<FileType.VIDEO: 'video'>})
+    """
+    video_type = _VIDEO_TYPE_OF_LEGACY_SOURCE.get(option.source)
+    if video_type is not None:
+        option.source = SourceType.NATIVE
+        option.filetypes = types.combine_filetype_filters(
+            option.filetypes, {video_type}
+        )
+    option.filetypes = types.combine_filetype_filters(
+        option.filetypes, {types.FileType.VIDEO}
+    )
+    return option
+
+
 def can_geotag_videos(option: SourceOption) -> bool:
     """
     Whether process() can read positions for videos from the source: it has a
diff --git a/mapillary_tools/geotag/options.py b/mapillary_tools/geotag/options.py
index 896dab71d..a4ed25140 100644
--- a/mapillary_tools/geotag/options.py
+++ b/mapillary_tools/geotag/options.py
@@ -36,6 +36,12 @@ class SourceType(enum.Enum):
     "exiftool": SourceType.EXIFTOOL_RUNTIME,
 }
 
+# The names that --video_geotag_source takes besides those above. Before v0.14,
+# "video" read the video's own GPS in any format, as the native source does now
+VIDEO_SOURCE_TYPE_ALIAS: dict[str, SourceType] = {
+    "video": SourceType.NATIVE,
+}
+
 
 @dataclasses.dataclass
 class SourceOption:
diff --git a/tests/integration/test_process.py b/tests/integration/test_process.py
index 1027eaed4..0c37c6383 100644
--- a/tests/integration/test_process.py
+++ b/tests/integration/test_process.py
@@ -1032,6 +1032,28 @@ def test_process_video_geotag_source_with_exiftool_runtime(setup_data: py.path.l
     assert_descs_exact_equal(exiftool_descs, native_descs)
 
 
+def test_process_video_geotag_source_names_in_readme(setup_data: py.path.local):
+    """
+    The README names the source that reads a video's own GPS "video", and those
+    that read one format of it "gopro", "camm" and "blackvue"
+    """
+    video_path = str(setup_data.join("gopro_data").join("max-360mode.mp4"))
+
+    native_descs = run_process_for_descs(
+        ["--video_geotag_source", "native", video_path]
+    )
+    assert "error" not in native_descs[0]
+
+    for source in ["video", "gopro"]:
+        descs = run_process_for_descs(["--video_geotag_source", source, video_path])
+        assert_descs_exact_equal(native_descs, descs)
+
+    # A GoPro video has none of the GPS of the other formats
+    for source in ["camm", "blackvue"]:
+        descs = run_process_for_descs(["--video_geotag_source", source, video_path])
+        assert [d["error"]["type"] for d in descs] == ["MapillaryVideoGPSNotFoundError"]
+
+
 def test_process_geotag_everything_with_exiftool_runtime(setup_data: py.path.local):
     pytest_skip_if_not_exiftool_installed()
 
diff --git a/tests/unit/test_parse_source_option.py b/tests/unit/test_parse_source_option.py
index c3412f50e..3e4b81ae1 100644
--- a/tests/unit/test_parse_source_option.py
+++ b/tests/unit/test_parse_source_option.py
@@ -11,6 +11,7 @@
 from mapillary_tools import exceptions, sample_video
 from mapillary_tools.geotag.factory import parse_source_option, parse_source_options
 from mapillary_tools.geotag.options import SourceType
+from mapillary_tools.types import FileType
 
 
 class TestParseSourceOption:
@@ -58,11 +59,72 @@ def test_invalid_json_source(self, source):
             parse_source_option(source)
 
     def test_video_geotag_source(self):
-        with pytest.raises(exceptions.MapillaryBadParameterError):
+        with pytest.raises(exceptions.MapillaryBadParameterError) as excinfo:
             parse_source_options(
                 geotag_source=[], video_geotag_source=["foo"], geotag_source_path=None
             )
 
+        assert "(aliases: blackvue_videos, gopro_videos, exiftool, video)" in str(
+            excinfo.value
+        )
+
+    @pytest.mark.parametrize(
+        "source", ["video", '{"source": "video"}', "native", "video,native"]
+    )
+    def test_video_reads_videos_natively(self, source):
+        options = parse_source_options(
+            geotag_source=[], video_geotag_source=[source], geotag_source_path=None
+        )
+
+        for option in options:
+            assert option.source is SourceType.NATIVE
+            assert option.filetypes == {FileType.VIDEO}
+
+    @pytest.mark.parametrize(
+        "source, filetype",
+        [
+            ("gopro", FileType.GOPRO),
+            ("gopro_videos", FileType.GOPRO),
+            ('{"source": "gopro", "pattern": "%f"}', FileType.GOPRO),
+            ("camm", FileType.CAMM),
+            ("blackvue", FileType.BLACKVUE),
+            ("blackvue_videos", FileType.BLACKVUE),
+        ],
+    )
+    def test_legacy_sources_read_videos_of_their_type(self, source, filetype):
+        [option] = parse_source_options(
+            geotag_source=[], video_geotag_source=[source], geotag_source_path=None
+        )
+
+        assert option.source is SourceType.NATIVE
+        assert option.filetypes == {filetype}
+
+    def test_legacy_sources_of_images_are_kept(self):
+        options = parse_source_options(
+            geotag_source=["gopro", "blackvue_videos", "camm"],
+            video_geotag_source=[],
+            geotag_source_path=None,
+        )
+
+        assert [(o.source, o.filetypes) for o in options] == [
+            (SourceType.GOPRO, None),
+            (SourceType.BLACKVUE, None),
+            (SourceType.CAMM, None),
+        ]
+
+    @pytest.mark.parametrize("source", ["video", '{"source": "video"}'])
+    def test_video_is_not_an_image_source(self, source):
+        with pytest.raises(exceptions.MapillaryBadParameterError):
+            parse_source_options(
+                geotag_source=[source], video_geotag_source=[], geotag_source_path=None
+            )
+
+    def test_video_process_samples_by_legacy_source(self, tmp_path: Path):
+        [option] = sample_video._parse_video_sources(None, None, ["gopro"], tmp_path)
+
+        assert option.source is SourceType.NATIVE
+        assert option.filetypes == {FileType.GOPRO}
+
     def test_video_process(self, tmp_path: Path):
         with pytest.raises(exceptions.MapillaryBadParameterError):
             sample_video._parse_video_sources(["foo"], None, None, tmp_path)

From e551adeb86e8f4e99c09cacec851aaa5be3a84cf Mon Sep 17 00:00:00 2001
From: Caglar Pir <caglarp@meta.com>
Date: Fri, 23 Oct 2026 11:19:50 +0200
Subject: [PATCH 4/5] Read exiftool_xml from %g.xml by default, as the README
 documents

The README gives exiftool_xml the default pattern %g.xml, the XML named
after the video beside it, as gpx has %g.gpx and nmea %g.nmea. Without a
pattern or --geotag_source_path, it failed the run instead: process with
--video_geotag_source exiftool_xml, or with --geotag_source exiftool_xml
for images and videos alike, exited with "source_path must be provided
for EXIFTOOL_XML source" (exit 2).

Without a source path or a pattern, exiftool_xml now reads the XML named
after each image and video, beside it. A file without one is reported as
not found in the ExifTool XML, and left to the next source. A source
path or a pattern is used as before, and so is the video import path
that video_process gives a source without either.

On a BlackVue video and three images, each with the output of
`exiftool -X` beside it, the descriptions equal those of an explicit
{"source": "exiftool_xml", "pattern": "%g.xml"}.
---
 mapillary_tools/geotag/factory.py | 32 ++++++++++++--------
 tests/integration/test_process.py | 50 +++++++++++++++++++++++++++++++
 2 files changed, 70 insertions(+), 12 deletions(-)

diff --git a/mapillary_tools/geotag/factory.py b/mapillary_tools/geotag/factory.py
index 28ea3dd0e..50c60a641 100644
--- a/mapillary_tools/geotag/factory.py
+++ b/mapillary_tools/geotag/factory.py
@@ -47,6 +47,10 @@
     SourceType.CAMM: types.FileType.CAMM,
 }
 
+# The XML that the exiftool_xml source reads for a file, without a source path
+# or a pattern: the output of `exiftool -X` for it, named after it
+_EXIFTOOL_XML_DEFAULT_PATTERN = "%g.xml"
+
 # Sources that read a GPS track from outside the video file, as opposed to
 # re-reading the telemetry embedded in it
 EXTERNAL_GPS_SOURCES = frozenset({SourceType.GPX, SourceType.NMEA})
@@ -643,6 +647,20 @@ def _ensure_source_path(option: SourceOption) -> Path:
     return option.source_path.source_path
 
 
+def _exiftool_xml_source_path(option: SourceOption) -> SourcePathOption:
+    """
+    Where the exiftool_xml source finds the XML of an image or a video: at its
+    source path or by its pattern, or by default, as the README documents, in
+    the XML named after the file beside it
+
+    >>> _exiftool_xml_source_path(SourceOption(SourceType.EXIFTOOL_XML))
+    SourcePathOption(pattern='%g.xml', source_path=None)
+    """
+    if option.source_path is None:
+        return SourcePathOption(pattern=_EXIFTOOL_XML_DEFAULT_PATTERN)
+    return option.source_path
+
+
 def _build_image_geotag(option: SourceOption) -> base.GeotagImagesFromGeneric | None:
     """
     Build a GeotagImagesFromGeneric object based on the provided option.
@@ -663,14 +681,8 @@ def _build_image_geotag(option: SourceOption) -> base.GeotagImagesFromGeneric |
         )
 
     elif option.source is SourceType.EXIFTOOL_XML:
-        # This is to ensure 'video_process --geotag={"source": "exiftool_xml", "source_path": "/tmp/xml_path"}'
-        # to work
-        if option.source_path is None:
-            raise exceptions.MapillaryBadParameterError(
-                "source_path must be provided for EXIFTOOL_XML source"
-            )
         return geotag_images_from_exiftool.GeotagImagesFromExifToolWithSamples(
-            source_path=option.source_path,
+            source_path=_exiftool_xml_source_path(option),
             num_processes=option.num_processes,
         )
 
@@ -758,12 +770,8 @@ def _build_video_geotag(option: SourceOption) -> base.GeotagVideosFromGeneric |
         )
 
     elif option.source is SourceType.EXIFTOOL_XML:
-        if option.source_path is None:
-            raise exceptions.MapillaryBadParameterError(
-                "source_path must be provided for EXIFTOOL_XML source"
-            )
         return geotag_videos_from_exiftool.GeotagVideosFromExifToolXML(
-            source_path=option.source_path,
+            source_path=_exiftool_xml_source_path(option),
         )
 
     elif option.source is SourceType.GPX:
diff --git a/tests/integration/test_process.py b/tests/integration/test_process.py
index 0c37c6383..ee40a0f16 100644
--- a/tests/integration/test_process.py
+++ b/tests/integration/test_process.py
@@ -17,6 +17,7 @@
     assert_contains_image_descs,
     assert_descs_exact_equal,
     EXECUTABLE,
+    EXIFTOOL_EXECUTABLE,
     pytest_skip_if_not_exiftool_installed,
     run_command,
     run_exiftool_and_generate_geotag_args,
@@ -1172,6 +1173,55 @@ def test_process_geotag_with_exiftool_xml_pattern(setup_data: py.path.local):
     assert_descs_exact_equal(exiftool_descs, native_descs)
 
 
+def test_process_geotag_with_exiftool_xml_default_pattern(setup_data: py.path.local):
+    """
+    Without a source path or a pattern, exiftool_xml reads the XML named after
+    each image and video, beside it: %g.xml, as the README documents
+    """
+    pytest_skip_if_not_exiftool_installed()
+
+    paths = [
+        str(setup_data.join("images")),
+        str(setup_data.join("gopro_data").join("max-360mode.mp4")),
+    ]
+    subprocess.run(
+        [
+            EXIFTOOL_EXECUTABLE,
+            *["-fast", "-q", "-n", "-X", "-ee"],
+            *["-api", "LargeFileSupport=1"],
+            *["-w!", "%d%f.xml"],
+            *paths,
+        ],
+        check=True,
+    )
+    assert setup_data.join("gopro_data").join("max-360mode.xml").check()
+
+    native_descs = run_process_for_descs([*["--geotag_source", "native"], *paths])
+
+    descs = run_process_for_descs([*["--geotag_source", "exiftool_xml"], *paths])
+    assert_descs_exact_equal(native_descs, descs)
+
+    native_video_descs = run_process_for_descs(
+        [*["--video_geotag_source", "native"], paths[1]]
+    )
+    video_descs = run_process_for_descs(
+        [*["--video_geotag_source", "exiftool_xml"], paths[1]]
+    )
+    assert_descs_exact_equal(native_video_descs, video_descs)
+
+
+def test_process_geotag_with_exiftool_xml_default_pattern_missing_file(
+    setup_data: py.path.local,
+):
+    video_path = setup_data.join("videos").join("sample-5s.mp4")
+    descs = run_process_for_descs(
+        [*["--video_geotag_source", "exiftool_xml"], str(video_path)]
+    )
+
+    assert len(descs) == 1
+    assert descs[0]["error"]["type"] == "MapillaryExifToolXMLNotFoundError"
+
+
 def test_process_geotag_with_exiftool_xml_pattern_missing_file(
     setup_data: py.path.local,
 ):

From 94322793245b988d88f48f5f7ecea2e989945b41 Mon Sep 17 00:00:00 2001
From: Caglar Pir <caglarp@meta.com>
Date: Fri, 23 Oct 2026 11:48:45 +0200
Subject: [PATCH 5/5] Read the file that the exiftool_runtime pattern names for
 a video

The README geotags videos stitched by Insta360 Studio by the originals
they were stitched from:

    mapillary_tools process \
    --video_geotag_source gpx \
    --video_geotag_source '{"source": "exiftool_runtime", "pattern": "../%g.insv"}' \
    VIDEO_DIR/

The exiftool_runtime source dropped the pattern, and ran ExifTool on the
stitched video itself, which has no GPS: the example failed every video
without a GPX with "No GPS data found from the video". Read with -fast,
the original would have had no GPS either: ExifTool then skips the
trailer at the end of an Insta360 original, which holds it.

The exiftool_runtime source now runs ExifTool on the file that its
pattern names for each video, and describes the video by that file's
metadata. A video whose file is not found is reported as such, and left
to the next source. Without a pattern it reads the video itself, as
before; the source path that --geotag_source_path, or the video import
path in video_process, gives every source is still not read. Videos are
read without -fast: on 35 sample videos from 20 cameras, that changes
ExifTool's output only for the Insta360 originals, and takes 45 s for
all of them where -fast takes 41 s. Images are read as before.

On an Insta360 X3 video stitched by Insta360 Studio, without a GPX, the
README example now geotags it by its original, where it exited 6.
---
 mapillary_tools/exiftool_runner.py            |  12 +-
 mapillary_tools/geotag/factory.py             |   6 +-
 .../geotag/geotag_videos_from_exiftool.py     |  59 ++++++-
 tests/integration/test_process.py             |  41 +++++
 ...test_geotag_videos_from_exiftool_runner.py | 161 ++++++++++++++++++
 5 files changed, 268 insertions(+), 11 deletions(-)
 create mode 100644 tests/unit/test_geotag_videos_from_exiftool_runner.py

diff --git a/mapillary_tools/exiftool_runner.py b/mapillary_tools/exiftool_runner.py
index bb8a39de4..beb41bc3b 100644
--- a/mapillary_tools/exiftool_runner.py
+++ b/mapillary_tools/exiftool_runner.py
@@ -15,14 +15,22 @@ class ExiftoolRunner:
     Wrapper around ExifTool to run it in a subprocess
     """
 
-    def __init__(self, exiftool_executable: str = "exiftool", recursive: bool = False):
+    def __init__(
+        self,
+        exiftool_executable: str = "exiftool",
+        recursive: bool = False,
+        fast: bool = True,
+    ):
         self.exiftool_executable = exiftool_executable
         self.recursive = recursive
+        # -fast skips metadata at the end of a file, such as the trailer that
+        # holds the GPS of an Insta360 original (.insv)
+        self.fast = fast
 
     def _build_args_read_stdin(self) -> list[str]:
         args: list[str] = [
             self.exiftool_executable,
-            "-fast",
+            *(["-fast"] if self.fast else []),
             "-q",
             "-n",  # Disable print conversion
             "-X",  # XML output
diff --git a/mapillary_tools/geotag/factory.py b/mapillary_tools/geotag/factory.py
index 50c60a641..e8f2f6bc6 100644
--- a/mapillary_tools/geotag/factory.py
+++ b/mapillary_tools/geotag/factory.py
@@ -765,8 +765,12 @@ def _build_video_geotag(option: SourceOption) -> base.GeotagVideosFromGeneric |
         )
 
     if option.source is SourceType.EXIFTOOL_RUNTIME:
+        # Only by its own pattern: the source path that --geotag_source_path, or
+        # the video import path in video_process, gives every source is not one
+        # for exiftool to read
         return geotag_videos_from_exiftool.GeotagVideosFromExifToolRunner(
-            num_processes=option.num_processes
+            pattern=None if option.source_path is None else option.source_path.pattern,
+            num_processes=option.num_processes,
         )
 
     elif option.source is SourceType.EXIFTOOL_XML:
diff --git a/mapillary_tools/geotag/geotag_videos_from_exiftool.py b/mapillary_tools/geotag/geotag_videos_from_exiftool.py
index 98af8ba4c..19e538d12 100644
--- a/mapillary_tools/geotag/geotag_videos_from_exiftool.py
+++ b/mapillary_tools/geotag/geotag_videos_from_exiftool.py
@@ -105,29 +105,65 @@ def find_rdf_by_path(
 
 
 class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
+    def __init__(self, pattern: str | None = None, num_processes: int | None = None):
+        super().__init__(num_processes=num_processes)
+        # Names the file to read for each video, after the video: by default
+        # the video itself, but the GPS of a stitched video can be in the
+        # original that it was stitched from (e.g. "../%g.insv")
+        self.source_path = (
+            None if pattern is None else options.SourcePathOption(pattern=pattern)
+        )
+
     @override
     def _generate_video_extractors(
         self, video_paths: T.Sequence[Path]
     ) -> T.Sequence[VideoExifToolExtractor | types.ErrorMetadata]:
+        results: list[VideoExifToolExtractor | types.ErrorMetadata] = []
+
+        # The file to read for each video
+        read_paths: dict[Path, Path] = {}
+        for video_path in video_paths:
+            if self.source_path is None:
+                read_path = video_path
+            else:
+                read_path = self.source_path.resolve(video_path)
+            if read_path.is_file():
+                read_paths[video_path] = read_path
+            else:
+                results.append(
+                    types.describe_error_metadata(
+                        exceptions.MapillaryVideoGPSNotFoundError(
+                            f"File not found for video: {read_path}"
+                        ),
+                        video_path,
+                        filetype=types.FileType.VIDEO,
+                    )
+                )
+
+        if not read_paths:
+            return results
+
+        # Not -fast, which skips the trailer that holds the GPS of an Insta360
+        # original
         if constants.EXIFTOOL_PATH is None:
-            runner = ExiftoolRunner()
+            runner = ExiftoolRunner(fast=False)
         else:
-            runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
+            runner = ExiftoolRunner(constants.EXIFTOOL_PATH, fast=False)
 
         LOG.debug(
             "Extracting XML from %d videos with ExifTool command: %s",
-            len(video_paths),
+            len(read_paths),
             " ".join(runner._build_args_read_stdin()),
         )
         try:
-            xml = runner.extract_xml(video_paths)
+            xml = runner.extract_xml(list(dict.fromkeys(read_paths.values())))
         except FileNotFoundError as ex:
             exiftool_ex = exceptions.MapillaryExiftoolNotFoundError(ex)
-            return [
+            return results + [
                 types.describe_error_metadata(
                     exiftool_ex, video_path, filetype=types.FileType.VIDEO
                 )
-                for video_path in video_paths
+                for video_path in read_paths
             ]
 
         try:
@@ -144,6 +180,13 @@ def _generate_video_extractors(
                 xml_element
             )
 
-        return GeotagVideosFromExifToolXML.build_video_extractors_from_etree(
-            rdf_by_path, video_paths
+        # Each video with the metadata of the file read for it
+        rdf_by_video_path = {
+            exiftool_read.canonical_path(video_path): rdf
+            for video_path, read_path in read_paths.items()
+            if (rdf := rdf_by_path.get(exiftool_read.canonical_path(read_path)))
+            is not None
+        }
+        return results + GeotagVideosFromExifToolXML.build_video_extractors_from_etree(
+            rdf_by_video_path, list(read_paths)
         )
diff --git a/tests/integration/test_process.py b/tests/integration/test_process.py
index ee40a0f16..b16b982d7 100644
--- a/tests/integration/test_process.py
+++ b/tests/integration/test_process.py
@@ -1055,6 +1055,47 @@ def test_process_video_geotag_source_names_in_readme(setup_data: py.path.local):
         assert [d["error"]["type"] for d in descs] == ["MapillaryVideoGPSNotFoundError"]
 
 
+def test_process_video_geotag_source_with_exiftool_runtime_pattern(
+    setup_data: py.path.local,
+):
+    """
+    As the README geotags a stitched video by the original it was stitched
+    from: exiftool_runtime reads the file that its pattern names after the video
+    """
+    pytest_skip_if_not_exiftool_installed()
+
+    original_path = setup_data.join("gopro_data").join("max-360mode.mp4")
+    stitched_dir = setup_data.join("gopro_data").mkdir("stitched")
+    # A video without GPS of its own, named after the original
+    stitched_path = stitched_dir.join("max-360mode.mp4")
+    setup_data.join("videos").join("sample-5s.mp4").copy(stitched_path)
+
+    descs = run_process_for_descs(
+        [
+            *[
+                "--video_geotag_source",
+                json.dumps({"source": "exiftool_runtime", "pattern": "../%g.mp4"}),
+            ],
+            str(stitched_dir),
+        ]
+    )
+    original_descs = run_process_for_descs(
+        [*["--video_geotag_source", "exiftool_runtime"], str(original_path)]
+    )
+
+    assert [Path(d["filename"]).name for d in descs] == ["max-360mode.mp4"]
+    assert Path(descs[0]["filename"]).parent.name == "stitched"
+    assert descs[0]["MAPDeviceModel"] == "GoPro Max"
+    assert len(descs[0]["MAPGPSTrack"]) > 0
+    assert descs[0]["MAPGPSTrack"] == original_descs[0]["MAPGPSTrack"]
+
+    # Without the pattern, the video's own metadata has no GPS
+    descs = run_process_for_descs(
+        [*["--video_geotag_source", "exiftool_runtime"], str(stitched_dir)]
+    )
+    assert descs[0]["error"]["type"] == "MapillaryVideoGPSNotFoundError"
+
+
 def test_process_geotag_everything_with_exiftool_runtime(setup_data: py.path.local):
     pytest_skip_if_not_exiftool_installed()
 
diff --git a/tests/unit/test_geotag_videos_from_exiftool_runner.py b/tests/unit/test_geotag_videos_from_exiftool_runner.py
new file mode 100644
index 000000000..c20e7ec45
--- /dev/null
+++ b/tests/unit/test_geotag_videos_from_exiftool_runner.py
@@ -0,0 +1,161 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+The exiftool_runtime source reads each video, or the file that its pattern
+names after the video, such as the Insta360 original of a stitched video.
+"""
+
+from __future__ import annotations
+
+import typing as T
+from pathlib import Path
+
+import pytest
+from mapillary_tools import exceptions, exiftool_runner, types
+from mapillary_tools.geotag import factory
+from mapillary_tools.geotag.options import SourceOption, SourcePathOption, SourceType
+
+
+def _rdf(path: Path, model: str) -> str:
+    return f"""\
+<rdf:Description rdf:about='{path.resolve().as_posix()}'
+ xmlns:IFD0='http://ns.exiftool.org/EXIF/IFD0/1.0/'
+ xmlns:QuickTime='http://ns.exiftool.org/QuickTime/QuickTime/1.0/'>
+ <IFD0:Make>Insta360</IFD0:Make>
+ <IFD0:Model>{model}</IFD0:Model>
+ <QuickTime:GPSDateTime>2023:08:25 14:19:28Z</QuickTime:GPSDateTime>
+ <QuickTime:GPSLatitude>47.3598583</QuickTime:GPSLatitude>
+ <QuickTime:GPSLongitude>8.5211333</QuickTime:GPSLongitude>
+ <QuickTime:GPSDateTime>2023:08:25 14:19:38Z</QuickTime:GPSDateTime>
+ <QuickTime:GPSLatitude>47.3594</QuickTime:GPSLatitude>
+ <QuickTime:GPSLongitude>8.5216</QuickTime:GPSLongitude>
+</rdf:Description>"""
+
+
+class _FakeRunner:
+    """
+    Stands in for ExifTool: the XML of the files it is given, each described as
+    a camera model named after the file
+    """
+
+    def __init__(self, calls: list[tuple[bool, list[Path]]]):
+        self.calls = calls
+
+    def __call__(self, *args, fast: bool = True, **kwargs) -> _FakeRunner:
+        self.fast = fast
+        return self
+
+    def _build_args_read_stdin(self) -> list[str]:
+        return ["exiftool"]
+
+    def extract_xml(self, paths: T.Sequence[Path]) -> str:
+        self.calls.append((self.fast, list(paths)))
+        descriptions = "\n".join(_rdf(path, path.name) for path in paths)
+        return (
+            "<?xml version='1.0' encoding='UTF-8'?>\n"
+            "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>\n"
+            f"{descriptions}\n</rdf:RDF>"
+        )
+
+
+@pytest.fixture
+def exiftool_calls(monkeypatch: pytest.MonkeyPatch) -> list[tuple[bool, list[Path]]]:
+    calls: list[tuple[bool, list[Path]]] = []
+    monkeypatch.setattr(
+        "mapillary_tools.geotag.geotag_videos_from_exiftool.ExiftoolRunner",
+        _FakeRunner(calls),
+    )
+    return calls
+
+
+def _process(video_path: Path, option: SourceOption) -> types.MetadataOrError:
+    option.filetypes = {types.FileType.VIDEO}
+    [metadata] = factory.process([video_path], [option])
+    return metadata
+
+
+def test_the_video_itself_by_default(tmp_path: Path, exiftool_calls):
+    video_path = tmp_path / "stitched" / "VID_00_006.mp4"
+    video_path.parent.mkdir()
+    video_path.write_bytes(b"")
+
+    metadata = _process(video_path, SourceOption(SourceType.EXIFTOOL_RUNTIME))
+
+    assert isinstance(metadata, types.VideoMetadata)
+    assert metadata.filename == video_path
+    assert metadata.model == "VID_00_006.mp4"
+    assert exiftool_calls == [(False, [video_path.resolve()])]
+
+
+def test_the_file_the_pattern_names(tmp_path: Path, exiftool_calls):
+    video_path = tmp_path / "stitched" / "VID_00_006.mp4"
+    video_path.parent.mkdir()
+    video_path.write_bytes(b"")
+    original_path = tmp_path / "VID_00_006.insv"
+    original_path.write_bytes(b"")
+
+    metadata = _process(
+        video_path,
+        SourceOption(
+            SourceType.EXIFTOOL_RUNTIME,
+            source_path=SourcePathOption(pattern="../%g.insv"),
+        ),
+    )
+
+    # The video, with the metadata of its original
+    assert isinstance(metadata, types.VideoMetadata)
+    assert metadata.filename == video_path
+    assert metadata.model == "VID_00_006.insv"
+    assert len(metadata.points) == 2
+    assert exiftool_calls == [(False, [original_path.resolve()])]
+
+
+def test_a_file_the_pattern_names_not_found(tmp_path: Path, exiftool_calls):
+    video_path = tmp_path / "VID_00_006.mp4"
+    video_path.write_bytes(b"")
+
+    metadata = _process(
+        video_path,
+        SourceOption(
+            SourceType.EXIFTOOL_RUNTIME,
+            source_path=SourcePathOption(pattern="../%g.insv"),
+        ),
+    )
+
+    assert isinstance(metadata, types.ErrorMetadata)
+    assert isinstance(metadata.error, exceptions.MapillaryVideoGPSNotFoundError)
+    assert str(metadata.error).startswith("File not found for video: ")
+    assert exiftool_calls == []
+
+
+def test_not_the_source_path_given_to_every_source(tmp_path: Path, exiftool_calls):
+    """
+    --geotag_source_path, or the video import path in video_process, is not a
+    file for exiftool to read for each video
+    """
+    video_path = tmp_path / "VID_00_006.mp4"
+    video_path.write_bytes(b"")
+    gpx_path = tmp_path / "track.gpx"
+    gpx_path.write_text("")
+
+    metadata = _process(
+        video_path,
+        SourceOption(
+            SourceType.EXIFTOOL_RUNTIME,
+            source_path=SourcePathOption(source_path=gpx_path),
+        ),
+    )
+
+    assert isinstance(metadata, types.VideoMetadata)
+    assert exiftool_calls == [(False, [video_path.resolve()])]
+
+
+def test_fast_skips_the_end_of_files():
+    assert "-fast" in exiftool_runner.ExiftoolRunner()._build_args_read_stdin()
+    assert (
+        "-fast"
+        not in exiftool_runner.ExiftoolRunner(fast=False)._build_args_read_stdin()
+    )