A camera frame and a LiDAR observation can describe the same maneuver while carrying very different device timestamps. A batch delivery adds another complication: data acquired at separate times may become available together. How should an ADTF session preserve those distinctions?

The recording-to-replay guide introduced the ACC cut-in workflow. Here, we follow six fictional samples through their clock mapping, arrival at the Recorder and playback. The question is precise: which time tells us when a measurement happened, and which tells us when it became available?

1 · Different clocks need a defined relationship

Assume the camera, LiDAR and vehicle interface have independent counters. At reference time zero, their readings are 50,000, 20,000 and 90,000 ms. The camera runs 100 parts per million faster than the reference, the LiDAR 200 ppm slower; the vehicle counter has the same rate in this simplified model.

At reference time 1,000 ms, the three readings differ:

Clock offset and rate difference
One reference instant, three different device-clock readings At the same reference instant of 1000 milliseconds, the fictional camera clock reads 51000.100 milliseconds, the LiDAR clock 20999.800 milliseconds and the vehicle clock 91000.000 milliseconds. A separate known mapping for each clock maps all three readings to the same reference instant. These are clock readings, not a claim that sensors acquire simultaneously. One reference instant, three device-clock readings Fictional clock models · Values in milliseconds · Reference instant: 1,000 ms DEVICE CLOCK SHARED ADTF STREAM TIME Camera51,000.100 msExample rate difference: +100 ppm LiDAR20,999.800 msExample rate difference: −200 ppm Vehicle interface91,000.000 msExample rate difference: 0 ppm Per-deviceclock mapping Offset + raterelationship A separate relationshipfor each clock domain 1,000 msSame reference instant 1,000 msSame reference instant 1,000 msSame reference instant
Clock readings at one shared reference instant. This does not imply simultaneous sensor acquisition. The diagram illustrates known clock relationships, not the internal implementation or measured output of Sync2Ref.
Known clock models for this examplecamera_device_ms = 50000 + 1.0001 × reference_mslidar_device_ms = 20000 + 0.9998 × reference_msvehicle_device_ms = 90000 + reference_ms

Subtracting the initial offsets alone would leave a growing error. After 10,000 reference milliseconds, the offset-corrected camera counter reads 10,001 ms and the LiDAR 9,998 ms: a 3 ms difference caused by their rate mismatch. Changing a transport buffer cannot correct this clock relationship.

2 · Map the source timestamp into ADTF Stream Time

ADTF uses ADTF Stream Time as its common processing time base. Source components can map external device timestamps into that domain. The Sync2Ref interfaces provide conversions that account for clock offset and drift.

In our known-clock model, the camera conversion is (device_ms − 50000) / 1.0001; for LiDAR it is (device_ms − 20000) / 0.9998. Both readings in the diagram map to 1,000 ms. These equations explain the example, rather than prescribing a Sync2Ref algorithm.

The source implementation must define what its timestamp represents: exposure, scan timing, device reception or another event. Use the appropriate clock-domain mapping and units. Real synchronization must estimate and track the relationship within the accuracy required for the investigation.

3 · A batch arrival still contains separate measurement times

Now assume the camera delivers frames individually. The LiDAR API delivers three timestamped items together at 1,040 ms. They were acquired at mapped times 1,000, 1,010 and 1,020 ms.

The example’s source adapter creates one ADTF sample per item and assigns each its mapped measurement time. Its three samples reach the Recorder at 1,041, 1,042 and 1,043 ms. That behavior belongs to the adapter design; ADTF does not automatically infer individual acquisition times from an unlabelled batch.

Acquisition time versus batch delivery
Separate measurement times survive a batch delivery Three LiDAR items are acquired at mapped times 1000, 1010 and 1020 milliseconds. The API delivers the batch at 1040 milliseconds. In this fictional source adapter, the three resulting ADTF samples retain their individual measurement times and reach the Recorder at 1041, 1042 and 1043 milliseconds. Three acquisition times, one batch callback Measurement times below have already been mapped to ADTF Stream Time. 1,0001,0101,0201,0301,040 ms L0L1L2 API batch Source adapter → individual ADTF samples L0Sample time: 1,000 msRecorder arrival: 1,041 ms L1Sample time: 1,010 msRecorder arrival: 1,042 ms L2Sample time: 1,020 msRecorder arrival: 1,043 ms A burst can still have distinct per-item arrival times. All values are illustrative. Batch delivery changes availability. It does not make the acquisitions simultaneous.
Illustrative per-item timing. The API callback occurs at 1,040 ms; separate ADTF samples arrive later at the Recorder. The displayed 1 ms spacing is an example assumption, not an ADTF throughput measurement.

The complete example includes two camera frames and one vehicle sample:

SampleDevice time
ms
Mapped sample time
ADTF ms
Recorder arrival
ADTF ms
C0 Camera51,000.1001,0001,004
L0 LiDAR20,999.8001,0001,041
V0 Vehicle91,005.0001,0051,007
L1 LiDAR21,009.7981,0101,042
C1 Camera51,020.1021,0201,024
L2 LiDAR21,019.7961,0201,043

Rows are arranged by mapped measurement time. C0 and L0 share a timestamp, as do C1 and L2; their listing order does not specify processing order.

If the adapter stamped every LiDAR item with the callback time, the distinction between the three acquisitions would be lost in that sample timestamp. Preserving the per-item device time is what allows the items to be related to the camera and vehicle data.

4 · The Recorder captures another point in the journey

The Recorder’s timebase_mode controls the file-item time base. With timebase_mode = 0, it records items with ADTF Stream Time at arrival. Our table therefore gives L0 a sample timestamp of 1,000 ms and a file-item, or chunk, timestamp of 1,041 ms.

Those values answer different questions: when the item was acquired in our defined source model, and when it reached this recording point. The Recorder’s timestamp is also separate from completion of the disk write.

The alternative timebase_mode = 1 uses sample timestamps for file items, replaces the original triggers and is limited to one input pin. It is a capture-time choice, not the Player’s reader setting. This multi-stream example retains mode 0.

5 · Choose the replay timeline for the engineering question

The Player documentation distinguishes two purposes. Default playback uses chunk timestamps to continue at the recording point. With our recording, C1 arrives before the older LiDAR items, reproducing availability at that tap.

Source-oriented resimulation can instead use sample timestamps. In the example, L0 belongs at 1,000 ms, before V0 at 1,005 ms, even though it reached the Recorder later.

Explore the same six samples

Continue at the recording point: items follow their recorded arrival times.

  1. C0 Camera
  2. V0 Vehicle
  3. C1 Camera
  4. L0 LiDAR
  5. L1 LiDAR
  6. L2 LiDAR

This control illustrates timestamp grouping; it does not configure or run ADTF. Equal timestamps do not establish an order within a group.

For sample-time playback, select the sorted_by_timestamps reader and review sort_by_sample_timestamp, the sorting window and generated triggers. The window must cover the data’s reordering span. This reader reorders items; it does not establish a missing clock relationship or repair invalid recordings in general.

The Playback Service coordinates delivery against ADTF Stream Time. Replay time is the session’s progression, not a third acquisition timestamp. Playback speed controls progression relative to wall time; changing it does not correct a sensor-clock offset.

Make the three decisions explicit

StageDecisionIn this example
Source adapterTimestamp meaning and clock mappingPreserve each acquisition time; map its device clock to ADTF Stream Time.
RecorderFile-item time basetimebase_mode = 0 retains arrival timing at the tap.
Player / readerPlayback time basisChunk time for the recording point; valid mapped sample time for source-oriented timing.

For the ACC cut-in, this separates clock mismatch, delivery delay and the recorded function response. Engineers can then interpret the event against an explicit timing model. Supplying a function again also requires the relevant recorded inputs, software and execution setup; a timestamp choice alone cannot recreate the vehicle.

Technical references

Sources checked: 18 November 2026. Property availability should be matched to the ADTF release in use.