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/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 bb7d20b3b..e8f2f6bc6 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,24 @@
 
 _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,
+}
+
+# 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})
 
 
-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 +66,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 +86,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 +99,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 +134,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 +159,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
@@ -197,6 +244,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 +265,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 +342,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:
@@ -489,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.
@@ -509,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,
         )
 
@@ -599,17 +765,17 @@ 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:
-        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/mapillary_tools/geotag/geotag_images_from_nmea_file.py b/mapillary_tools/geotag/geotag_images_from_nmea_file.py
index eb779c736..7b9bb6844 100644
--- a/mapillary_tools/geotag/geotag_images_from_nmea_file.py
+++ b/mapillary_tools/geotag/geotag_images_from_nmea_file.py
@@ -77,8 +77,12 @@ def _read_nmea_points(source_path: Path) -> list[geo.Point]:
 def get_lat_lon_time_from_nmea(nmea_file: Path) -> list[geo.Point]:
     """
     Read the fixes of an NMEA file: the time and position of each GGA
-    sentence, on the date of the last RMC sentence before it, or of the first
-    RMC sentence for the GGA sentences before any.
+    sentence, on the date of the RMC sentence of the same fix. Receivers
+    write the GGA sentence of a fix before or after its RMC sentence, so a
+    GGA sentence takes the date that puts it nearest the fix before it or the
+    RMC sentence after it, whichever it is nearer: the first fix after
+    midnight falls on the next day, also when the RMC sentence with that date
+    follows it.
 
     Receivers log sentences without a fix, such as before they acquire one:
     RMC sentences that are void or have no date or time, and GGA sentences
@@ -98,11 +102,14 @@ def get_lat_lon_time_from_nmea(nmea_file: Path) -> list[geo.Point]:
 
     messages = [pynmea2.parse(line) for line in lines if _SENTENCE_RE.search(line)]
 
-    # Get initial date
-    dates = [_fix_date(m) for m in messages if isinstance(m, pynmea2.RMC)]
-    date = next((d for d in dates if d is not None), None)
-    if date is None:
-        fixes = [m for m in messages if isinstance(m, pynmea2.GGA) and _has_fix(m)]
+    # The RMC sentences with a date, and the GGA sentences with a fix
+    fixes = [
+        m
+        for m in messages
+        if (isinstance(m, pynmea2.RMC) and _fix_date(m) is not None)
+        or (isinstance(m, pynmea2.GGA) and _has_fix(m))
+    ]
+    if not any(isinstance(m, pynmea2.RMC) for m in fixes):
         if fixes:
             LOG.warning(
                 "Ignoring the %d fixes in the NMEA file %s, as no RMC sentence gives their date",
@@ -111,26 +118,74 @@ def get_lat_lon_time_from_nmea(nmea_file: Path) -> list[geo.Point]:
             )
         return []
 
+    # The datetime of the next RMC sentence after each fix
+    next_rmc: list[datetime.datetime | None] = []
+    upcoming: datetime.datetime | None = None
+    for message in reversed(fixes):
+        next_rmc.append(upcoming)
+        if isinstance(message, pynmea2.RMC):
+            upcoming = _rmc_datetime(message)
+    next_rmc.reverse()
+
     # Parse GPS trace
     points = []
     times: set[float] = set()
-    for message in messages:
+    last: datetime.datetime | None = None
+    for message, after in zip(fixes, next_rmc):
         if isinstance(message, pynmea2.RMC):
-            date = _fix_date(message) or date
+            last = _rmc_datetime(message)
+            continue
 
-        elif isinstance(message, pynmea2.GGA) and _has_fix(message):
-            dt = datetime.datetime.combine(date, message.timestamp)
-            time = geo.as_unix_time(dt)
-            if time in times:
-                continue
-            times.add(time)
-            lat, lon, alt = message.latitude, message.longitude, message.altitude
-            points.append(geo.Point(time=time, lat=lat, lon=lon, alt=alt, angle=None))
+        last = _gga_datetime(message.timestamp, last, after)
+        time = geo.as_unix_time(last)
+        if time in times:
+            continue
+        times.add(time)
+        lat, lon, alt = message.latitude, message.longitude, message.altitude
+        points.append(geo.Point(time=time, lat=lat, lon=lon, alt=alt, angle=None))
 
     points.sort()
     return points
 
 
+def _rmc_datetime(message: pynmea2.RMC) -> datetime.datetime:
+    return datetime.datetime.combine(message.datestamp, message.timestamp)
+
+
+def _gga_datetime(
+    time: datetime.time,
+    before: datetime.datetime | None,
+    after: datetime.datetime | None,
+) -> datetime.datetime:
+    """
+    The datetime of a GGA sentence at **time** of day, after the fix **before**
+    it and before the RMC sentence **after** it: on the date, or the day before
+    or after it, that puts it nearest the one of them it is nearer
+
+    >>> before = datetime.datetime(2022, 12, 21, 23, 59, 59)
+    >>> after = datetime.datetime(2022, 12, 22, 0, 0, 0)
+    >>> _gga_datetime(datetime.time(0, 0, 0), before, after)
+    datetime.datetime(2022, 12, 22, 0, 0)
+    >>> _gga_datetime(datetime.time(0, 0, 0), before, None)
+    datetime.datetime(2022, 12, 22, 0, 0)
+    >>> _gga_datetime(datetime.time(23, 59, 59), None, after)
+    datetime.datetime(2022, 12, 21, 23, 59, 59)
+
+    The first fix of a log of another day, appended to the file:
+
+    >>> after = datetime.datetime(2022, 12, 24, 9, 0, 0)
+    >>> _gga_datetime(datetime.time(9, 0, 0), before, after)
+    datetime.datetime(2022, 12, 24, 9, 0)
+    """
+    candidates = [
+        (datetime.datetime.combine(near.date() + datetime.timedelta(days), time), near)
+        for near in (before, after)
+        if near is not None
+        for days in (-1, 0, 1)
+    ]
+    return min(candidates, key=lambda candidate: abs(candidate[0] - candidate[1]))[0]
+
+
 def _fix_date(message: pynmea2.RMC) -> datetime.date | None:
     """The date of an RMC sentence, or None if it is void or has no date or time"""
     if message.status != "A" or message.timestamp is None:
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/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/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/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..b16b982d7 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,
@@ -663,6 +664,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")
@@ -761,7 +823,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 +837,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 +871,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
@@ -972,6 +1033,69 @@ 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_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()
 
@@ -1090,6 +1214,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,
 ):
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_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:
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_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()
+    )
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_nmea_parser.py b/tests/unit/test_nmea_parser.py
index 49d6fd856..610a2b68f 100644
--- a/tests/unit/test_nmea_parser.py
+++ b/tests/unit/test_nmea_parser.py
@@ -133,6 +133,57 @@ def test_gga_before_the_first_rmc_take_its_date(tmp_path):
     ) == [_fix("02:46:35", lat=37.588435), _fix("02:46:36")]
 
 
+@pytest.mark.parametrize("gga_first", [True, False])
+def test_fixes_across_midnight(tmp_path, gga_first):
+    """
+    The first fix after midnight, logged before the RMC sentence with its
+    date, was dated a day early, a day before the rest of the track
+    """
+    lines = []
+    for time, date in [
+        ("235959.00", "211222"),
+        ("000000.00", "221222"),
+        ("000001.00", "221222"),
+    ]:
+        if gga_first:
+            lines += [_gga(time), _rmc(time, date=date)]
+        else:
+            lines += [_rmc(time, date=date), _gga(time)]
+
+    assert _read(tmp_path, *lines) == [
+        _fix("23:59:59", date="2022-12-21"),
+        _fix("00:00:00"),
+        _fix("00:00:01"),
+    ]
+
+
+def test_gga_before_the_first_rmc_across_midnight(tmp_path):
+    """It took the date of the RMC sentence, a day late"""
+    assert _read(
+        tmp_path,
+        _gga("235959.00", lat="3735.30610"),
+        _rmc("000000.00"),
+        _gga("000000.00"),
+    ) == [_fix("23:59:59", date="2022-12-21", lat=37.588435), _fix("00:00:00")]
+
+
+def test_a_log_of_another_day_appended(tmp_path):
+    """
+    Its first fix, logged before its RMC sentence, takes the date of that
+    sentence, not that of the fix before it
+    """
+    assert _read(
+        tmp_path,
+        _rmc("180000.00", date="211222"),
+        _gga("180000.00"),
+        _gga("090000.00", lat="3735.30610"),
+        _rmc("090000.00", date="241222"),
+    ) == [
+        _fix("18:00:00", date="2022-12-21"),
+        _fix("09:00:00", date="2022-12-24", lat=37.588435),
+    ]
+
+
 def test_gga_without_any_date_give_no_points(tmp_path, caplog):
     """They raised UnboundLocalError"""
     with caplog.at_level(logging.WARNING):
diff --git a/tests/unit/test_nmea_video.py b/tests/unit/test_nmea_video.py
index 0b8a09728..c4131b900 100644
--- a/tests/unit/test_nmea_video.py
+++ b/tests/unit/test_nmea_video.py
@@ -60,8 +60,16 @@ def _write_gpx(path: Path, seconds: int, start: datetime.datetime = START) -> Pa
     return path
 
 
-def _write_nmea(path: Path, seconds: int, start: datetime.datetime = START) -> Path:
-    """The track of _write_gpx(), as RMC and GGA sentences"""
+def _write_nmea(
+    path: Path,
+    seconds: int,
+    start: datetime.datetime = START,
+    gga_first: bool = False,
+) -> Path:
+    """
+    The track of _write_gpx(), as RMC and GGA sentences, the GGA sentence of
+    each fix first or last
+    """
     lines = []
     for time, lat, alt in _track(seconds, start):
         hhmmss = time.strftime("%H%M%S.00")
@@ -83,6 +91,8 @@ def _write_nmea(path: Path, seconds: int, start: datetime.datetime = START) -> P
                 + (f"{alt:.1f}", "M", "0.0", "M", "", ""),
             )
         )
+        if gga_first:
+            lines[-2:] = lines[-1:-3:-1]
     path.write_text("".join(f"{line}\r\n" for line in lines))
     return path
 
@@ -134,6 +144,24 @@ def test_the_track_is_placed_as_from_a_gpx(self, tmp_path, video, seconds, kwarg
         for nmea_point, gpx_point in zip(from_nmea, from_gpx):
             assert nmea_point == pytest.approx(gpx_point, abs=1e-6)
 
+    def test_a_track_across_midnight_is_placed_as_from_a_gpx(self, tmp_path):
+        """
+        Its first fix after midnight, logged before the RMC sentence with its
+        date, was dated a day early, and the video got a track of a day
+        """
+        start = datetime.datetime(
+            2019, 11, 18, 23, 59, 57, tzinfo=datetime.timezone.utc
+        )
+        gpx = _write_gpx(tmp_path / "track.gpx", 6, start)
+        nmea = _write_nmea(tmp_path / "track.nmea", 6, start, gga_first=True)
+
+        from_gpx = _points(GPXVideoExtractor(NO_GPS_VIDEO, gpx))
+        from_nmea = _points(NMEAVideoExtractor(NO_GPS_VIDEO, nmea))
+
+        assert len(from_nmea) == len(from_gpx) == 7
+        for nmea_point, gpx_point in zip(from_nmea, from_gpx):
+            assert nmea_point == pytest.approx(gpx_point, abs=1e-6)
+
     def test_messages_name_the_nmea_file(self, tmp_path):
         nmea = _write_nmea(tmp_path / "track.nmea", seconds=60)
 
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)
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"