YOULOOK CAR — SYNCHRONISATION VIDÉO

Comment relier, à l'image près, une vidéo et un fichier de télémétrie qui n'ont aucune horloge commune.

Le problème

Une caméra et un téléphone comptent le temps chacun de leur côté. Le fichier vidéo commence à zéro ; la télémétrie porte l'heure du téléphone. Rien, dans l'un ou l'autre, ne dit quelle image correspond au premier échantillon. Les métadonnées de création du fichier vidéo ne suffisent pas : elles sont arrondies à la seconde, décalées par le temps de démarrage de l'enregistrement, et parfois écrites à la fin du plan.

Une erreur d'une demi-seconde suffit à faire apparaître un pic de freinage alors que la voiture est déjà à l'arrêt.

La solution : le clap

C'est le principe du clap de cinéma, transposé. La caméra filme l'écran du téléphone, qui émet un flash blanc plein écran à des instants dont l'horodatage est connu à la milliseconde et inscrit dans les données.

Retrouver l'image du flash dans la vidéo suffit alors à caler les deux sources — sans horloge commune, sans réseau, sans matériel.

Marche à suivre

1. Dans l'application web, ouvrir ÉCRAN DE SYNCHRO VIDÉO.
2. Placer l'écran du téléphone dans le champ de la caméra.
3. Lancer l'enregistrement vidéo, puis START dans l'application.
4. Un flash part 2 secondes après le START, puis toutes les 30 secondes. On peut aussi en déclencher un à la main.
5. Le téléphone peut ensuite sortir du champ : les flashs suivants ne sont utiles que s'ils restent filmés.

Ce que contiennent les fichiers

Chaque flash est inscrit dans les deux formats exportés.

SRT — le champ [sync: 1]

Le bloc de sous-titre couvrant l'instant du flash porte le champ [sync: 1]. Sa deuxième ligne donne l'horodatage absolu.

1
00:00:02,000 --> 00:00:02,050
<font size="28">SrtCnt : 41, DiffTime : 50ms
2026-08-21 20:03:44.153
[latitude: 46.429520] [longitude: 6.920797] [speed: 12.4] [g_force: 1.01] [sync: 1] </font>

MDF4 — le canal « Repère de synchro »

Fichier ASAM MDF 4.10. Le canal Repère de synchro vaut 1 sur la seule ligne du flash, et NaN partout ailleurs. C'est un événement, jamais un niveau : il n'est pas prolongé par le maintien de valeur appliqué aux autres grandeurs.

L'algorithme de resynchronisation

1. Détecter le flash dans la vidéo. Calculer la luminance moyenne de chaque image. Le flash est un pic isolé très au-dessus de la médiane locale. Retenir la première image du pic — c'est le front montant qui fait référence, pas le milieu du palier. Noter son instant t_video, en secondes depuis le début du fichier.
2. Lire l'horodatage correspondant dans le SRT : le bloc portant [sync: 1], ligne 2. Soit t_data.
3. Calculer le décalage : offset = t_data − t_video.
4. Appliquer : tout échantillon d'horodatage T se place à l'instant vidéo T − offset.

Mesurer et corriger la dérive

Deux flashs ou plus permettent de faire mieux qu'un simple décalage. Les horloges de la caméra et du téléphone n'avancent pas exactement à la même vitesse : sur un plan de vingt minutes, l'écart atteint couramment quelques dizaines de millisecondes.

offset(T) = a · T + b

     avec  a, b  obtenus par régression linéaire
           sur l'ensemble des couples (t_data, t_video)

Avec un flash toutes les 30 secondes, la régression est très surdéterminée : la dérive résiduelle devient négligeable devant la durée d'une image.

Précision réellement atteignable

Détection automatique — code de référence

# Détection du clap Youlook Car dans une vidéo.
# Dépendances : OpenCV et NumPy, rien d'autre.

import cv2, numpy as np

def instants_des_flashs(chemin, tuiles=8, seuil=6.0, sous_ech=4):
    """Instants, en secondes, des fronts montants du flash.

    L'image est découpée en tuiles×tuiles cases. C'est le point clé : filmé
    d'un support, l'écran du téléphone n'occupe que quelques pour cent d'un
    cadre 4K. Sur la moyenne de l'image entière, un flash plein écran ne
    déplace alors la luminance que d'une fraction de point et se noie dans le
    bruit de scène. Case par case, il sature.

    La case retenue est celle dont la luminance s'écarte le plus fortement
    vers le haut : c'est celle qui contient l'écran, trouvée toute seule.
    """
    cap = cv2.VideoCapture(chemin)
    fps = cap.get(cv2.CAP_PROP_FPS)
    series = []
    while True:
        ok, img = cap.read()
        if not ok:
            break
        g = img[::sous_ech, ::sous_ech].mean(axis=2)
        h, w = g.shape
        bloc = g[:h // tuiles * tuiles, :w // tuiles * tuiles]
        bloc = bloc.reshape(tuiles, h // tuiles, tuiles, w // tuiles)
        series.append(bloc.mean(axis=(1, 3)).ravel())
    series = np.asarray(series)                    # (images, tuiles²)

    # Médiane glissante sur 2 s : insensible aux changements de scène lents.
    k = max(3, int(fps * 2) | 1)
    meilleur, resultat = -1.0, []
    for c in range(series.shape[1]):
        lum = series[:, c]
        fond = np.array([np.median(lum[max(0, i - k // 2): i + k // 2 + 1])
                         for i in range(len(lum))])
        ecart = max(float(np.median(np.abs(lum - fond))), 1e-6)
        force = (lum - fond) / ecart
        if force.max() > meilleur:
            haut = force > seuil * 3
            # FRONT MONTANT seulement : première image de chaque palier.
            fronts = np.flatnonzero(haut & ~np.r_[False, haut[:-1]])
            meilleur = force.max()
            resultat = [float(i) / fps for i in fronts]
    return resultat

Grammaire complète du SRT

Le format suit la grammaire de télémétrie DJI, pour rester lisible par les outils existants. Les clés supplémentaires sont ignorées sans dommage par un lecteur qui ne les connaît pas.

tops   = [(t, v) for t, v in canal("lap_mark") if v is not None]
depart = next(t for t, v in tops if v == 1)
lignes = [t for t, v in tops if v in (2, 3)]

tours = []
precedent = depart
for t in lignes:
    tours.append({"numero": len(tours) + 1, "duree": t - precedent})
    precedent = t