SAVAV contains simulated recordings of cars, vans and motorcycles passing, crossing, following or overtaking an ego vehicle that carries an 8-microphone array and three cameras. The scenes are simulated to match real recordings made on a test site with four environments: an open concrete taxiway with a T-junction, a road along a hedge, a junction next to a large hall, and a narrow access track in a thicket.

All the data are in the folder SAVAV_official/. Every run has its sound, the images of its three cameras, its ground-truth geometry and its labels, aligned second by second (see Alignment). This version contains 2 107 runs (17 h 35 min 45 s) simulated in overcast weather on a dry road.

Content

split	families	runs	duration (sound, images and labels)	annotation rows	download size
`NEW`	30	1 679	55 565 s (15 h 26 min 05 s)	91 465	358.9 GB (audio 14.1 GB, stems 90.8 GB, images 253.0 GB)
`FEV`	38	389	6 425 s (1 h 47 min 05 s)	7 459	22.4 GB (audio 1.5 GB, images 20.7 GB)
`TJ`	21	39	1 355 s (22 min 35 s)	1 882	3.4 GB (audio 0.2 GB, stems 1.6 GB, images 1.6 GB)
total	89	2 107	63 345 s (17 h 35 min 45 s)	100 806	384.7 GB (audio 15.9 GB, stems 92.4 GB, images 275.3 GB)

Every second of every run is labelled and has its 8-channel sound and 20 images per camera; a second with vehicles on two sides of the ego has two annotation rows.

NEW: new scenarios with 1 to 4 vehicles around a parked or driving ego (pass-bys, crossings, overtakes, lead and following vehicles, the ego pulling out at a junction), with mirrored variants.
FEV: replays of the real recordings, same vehicles and same trajectories.
TJ: replays of the T-junction recordings, ego parked at 10, 50 and 100 m from the junction.

Alignment of sound, images and labels

A run lasts a whole number of seconds n. Second k (0 <= k < n) is made of:

modality	second `k`
sound	samples `48000 k` to `48000 k + 47999` of `audio_8ch.flac` and of every stem
video	frames `20 k` to `20 k + 19` of `cameras/cam0.mp4`, `cam1.mp4` and `cam2.mp4` (times `k`, `k + 0.05`, ..., `k + 0.95` s)
1-fps images	frame `20 k + 10` (time `k + 0.5` s) of each camera, in `frames_1fps.tar`
geometry	rows `20 k` to `20 k + 19` of `geometry.csv` and of `frames_index.csv` (`time_s` = frame / 20)
labels	the row(s) with `chunk_idx` = `start_s` = `k`; per-vehicle distances, speeds and azimuths are taken at `k + 0.5` s

audio_8ch.flac has exactly 48000 n samples. The videos, geometry.csv and frames_index.csv have 20 n + 1 frames or rows: the last one, at time n, closes the run and belongs to no second. Nothing is published without its counterpart: there is no sound without images, no image without sound and no second without labels.

The FEV and TJ runs replay real recordings: what is published is a part of the simulated scene, given in scene.json → publication (scene_start_s, scene_end_s, duration_s). The times inside scene.json (trajectories, start times) are scene times: subtract scene_start_s to compare them with the other files, which all start at 0. A NEW run is published whole, from scene time 0.

Preparing the data for a model (20 fps)

The unit of the dataset is the second: one second of sound (48 000 samples x 8 microphones), its 20 frames per camera and its label row(s). The simplest correct way to cut a run is by frame number, never by duration:

read the sound and take n = len(audio) // 48000 seconds;
decode each video and keep frames 0 to 20 n - 1; frame 20 n (the last one) closes the run and is dropped;
second k = audio[48000 k : 48000 (k + 1)], frames[20 k : 20 k + 20], rows 20 k to 20 k + 19 of geometry.csv, and the label row(s) with chunk_idx == k.

import os
import av                      # pip install av
import numpy as np
import soundfile as sf

def seconds(run_dir, cam="cam1"):
    """Yields (k, the 20 frames of second k as an array (20, 1024, 1224, 3), the sound of second k (48000, 8)), one second at a time."""
    audio, fs = sf.read(os.path.join(run_dir, "audio_8ch.flac"), dtype="int16")
    n = len(audio) // 48000
    frames = []
    with av.open(os.path.join(run_dir, "cameras", cam + ".mp4")) as video:
        for i, frame in enumerate(video.decode(video=0)):
            if i >= 20 * n:                       # frame 20 n closes the run: it belongs to no second
                break
            frames.append(frame.to_ndarray(format="rgb24"))
            if len(frames) == 20:
                k = i // 20
                yield k, np.stack(frames), audio[48000 * k: 48000 * (k + 1)]
                frames = []

Good to know:

A 30 s run has 601 frames, and the video header gives 30.05 s. Do not stretch or resample the video to the length of the sound, and do not reshape all the frames into blocks of 20 (601 is not a multiple of 20): keep frames[:20 * n].
Lower frame rates: 10 fps = frames 20 k, 20 k + 2, ..., 20 k + 18; 5 fps = one frame out of four from 20 k; 1 fps = frame 20 k + 10, already extracted in frames_1fps.tar (tools/extract_frames.py --fps 10 writes the 10 fps frames).
The three cameras are synchronous: frame i of cam0.mp4, cam1.mp4 and cam2.mp4 is the same instant, i / 20 s.
tools/reformat_to_chunks.py cuts the sound into one file per second with the same numbering.

Layout

SAVAV_official/
├── annotations/
│   ├── annotations_NEW.csv  annotations_NEW.xlsx      all rows of a split (sheets long and legend in the .xlsx)
│   ├── annotations_FEV.csv  annotations_FEV.xlsx
│   └── annotations_TJ.csv   annotations_TJ.xlsx
├── tools/                                             scripts described below
├── NEW/<family>/<run>/
│   ├── audio_8ch.flac
│   ├── stems/<vehicle>.flac, stems/background.flac, stems/README.txt
│   ├── cameras/cam0.mp4, cameras/cam1.mp4, cameras/cam2.mp4
│   ├── frames_1fps.tar
│   ├── frames_index.csv
│   ├── geometry.csv
│   ├── scene.json
│   └── annotations.csv
├── FEV/<family>/<run>/                                same files, without stems/
└── TJ/<family>/<run>/                                 same files as NEW

Files of a run

file	content
`audio_8ch.flac`	the 8 microphones of the ego vehicle, 48 kHz, 16-bit (what the array hears)
`stems/<vehicle>.flac`, `stems/background.flac`	the same 8 channels for each vehicle alone and for the background (ambient noise and ego self-noise), 24-bit; `audio_8ch` = background + sum of the vehicle tracks. Present for every `NEW` and `TJ` run; the `FEV` runs have no stems
`cameras/cam0.mp4`, `cam1.mp4`, `cam2.mp4`	left, front and right cameras of the ego vehicle, 1224 x 1024, 20 fps, H.264, no sound
`frames_1fps.tar`	one JPEG per second and per camera (frame `20 k + 10`), named `frames_1fps/<run>_<cam>_<frame>.jpg`
`frames_index.csv`	one row per video frame: time, environment, ego position and heading, camera position, frame number and JPEG name of each camera, position, heading and speed of every vehicle
`geometry.csv`	ground truth at 20 Hz: positions (local East-North frame in metres, and WGS84), headings and speeds of the ego vehicle, of the microphone array and of every vehicle
`scene.json`	scenario definition: vehicle classes, paths, speeds, start times (and the `publication` interval for `FEV` and `TJ`)
`annotations.csv`	the rows of this run (same columns as the split files, without `chunk_folder`)

Labels

SAVAV_official/annotations/annotations_<split>.csv (and the same table in .xlsx, with a legend sheet that describes every column) holds one row per second, per run and per occupied side.

audio_path is the run's audio_8ch.flac; the row covers [start_s, start_s + 1) seconds of that file (start_s = chunk_idx), and frames 20 start_s to 20 start_s + 19 of the videos.
scenario_key = <family>___<run> identifies a run (some run names exist in several families).
chunk_folder = chunk_<A>_<B>: name of that second in the chunked layout below; B = chunk_idx, A = absolute chunk number (index of that second in the source recording for TJ, A = B for NEW and FEV).
left, front, right, back: side of the group (azimuth clockwise from the ego heading: front |az| <= 45°, right 45-135°, back |az| >= 135°, left -135 to -45°); none: no vehicle in that second; both: vehicles on more than one side. A second with vehicles on two sides has two rows.
car, van, moto, objects_combo, count: classes and number of vehicles of the group.
<vehicle>_distance_m, <vehicle>_speed_kmh, <vehicle>_side, <vehicle>_azimuth_deg: per-vehicle values at the middle of the second, the time of the 1-fps image.
ego_mode (static / driving), ego_speed_kmh, env (O taxiway, W hedge, F hall, T thicket), information (readable summary).

Download, step by step

Accept the conditions. Log in to Hugging Face, open this page and click Agree and access the dataset (access is granted at once).
Install the client (Python 3.9 or later): pip install -U huggingface_hub. This provides the hf command.
Log in. Create a token with the Read role at https://huggingface.co/settings/tokens, then run hf auth login and paste it (or set the environment variable HF_TOKEN).

Download the annotations and the tools first (about 82 MB) into a local folder, here SAVAV:

hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/annotations/*"
hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/tools/*"

Download the runs you need, one --include per command (and at most one --exclude); the files land in SAVAV/SAVAV_official/<split>/<family>/<run>/:

# one split with sound and images, without stems (TJ: 1.8 GB, NEW: 268.0 GB; FEV has no stems: 22.4 GB)
hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/TJ/*" --exclude "*/stems/*"
# one split, everything (TJ: 3.4 GB)
hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/TJ/*"
# one family
hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/NEW/two_vehicles/*"
# the whole dataset without stems (292.2 GB), or with stems (384.7 GB) without the --exclude
hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/*" --exclude "*/stems/*"

Add --dry-run to see the list and the total size before downloading. Re-running the same command after an interruption skips the files already complete.

The same in Python, with several patterns at once; for example the sound, geometry and labels of every run, without images and stems (16.9 GB; TJ 0.2 GB, FEV 1.6 GB, NEW 15.0 GB):

from huggingface_hub import snapshot_download

snapshot_download(repo_id="AnonymAccount/SAVAV", repo_type="dataset", local_dir="SAVAV",
                  allow_patterns=["SAVAV_official/*"],
                  ignore_patterns=["*/stems/*", "*/cameras/*", "*/frames_1fps.tar"])

The annotation tables can also be loaded with datasets (after step 3): load_dataset("AnonymAccount/SAVAV", "TJ", split="train"), and likewise "NEW" and "FEV".

Reading one second of sound and its images

import os
import pandas as pd
import soundfile as sf

root = "SAVAV"                                              # the --local-dir of the download
rows = pd.read_csv(os.path.join(root, "SAVAV_official/annotations/annotations_TJ.csv"), low_memory=False)
row = rows.iloc[0]
k = int(row["start_s"])
audio, fs = sf.read(os.path.join(root, row["audio_path"]), start=k * 48000, stop=(k + 1) * 48000, dtype="int16")   # (48000, 8)
run_dir = os.path.dirname(os.path.join(root, row["audio_path"]))
frames = range(20 * k, 20 * k + 20)                         # frames of cameras/cam0.mp4, cam1.mp4, cam2.mp4 for this second
jpeg = "frames_1fps/%s_cam1_%05d.jpg" % (os.path.basename(run_dir), 20 * k + 10)   # in <run_dir>/frames_1fps.tar
print(row["scenario_key"], row["information"], audio.shape, jpeg)

Reformatting to 1-second chunks, step by step

The original recordings are stored as one folder per second. tools/reformat_to_chunks.py rebuilds this layout from the download; the chunks are bit-exact slices of audio_8ch.flac.

Download the annotations, the tools and the runs to convert (steps 4 and 5 above).
Install the dependencies: pip install numpy soundfile pandas openpyxl.

Check the size of the output (the whole dataset gives 48.7 GB of WAV: NEW 42.7 GB, FEV 4.9 GB, TJ 1.0 GB):

python SAVAV/SAVAV_official/tools/reformat_to_chunks.py SAVAV/SAVAV_official --out SAVAV_chunks --dry-run

Convert (--splits TJ or --families two_vehicles to convert a part only, --workers 4 to use several cores):

python SAVAV/SAVAV_official/tools/reformat_to_chunks.py SAVAV/SAVAV_official --out SAVAV_chunks --workers 4

Result:
```
SAVAV_chunks/<split>/annotations_<split>.xlsx, annotations_<split>.csv
SAVAV_chunks/<split>/<family>/annotations_<family>.xlsx
SAVAV_chunks/<split>/<family>/<run>/audio_chunks/<chunk_folder>/chunk_full.wav    8 channels, 48 kHz, 16-bit, 48000 samples
SAVAV_chunks/<split>/<family>/<run>/geometry.csv, scene.json
```
In these annotation files audio_path points to the chunk file, relative to the folder that contains SAVAV_chunks (SAVAV_chunks/TJ/<family>/<run>/audio_chunks/chunk_000413_000000/chunk_full.wav). Options: --stems also places the stems, --keep-flac the full audio_8ch.flac, --format flac writes FLAC chunks. An interrupted conversion resumes where it stopped.

Tools

SAVAV_official/tools/ (see its README.md): reformat_to_chunks.py (chunked layout of whole splits, above), split_audio_chunks.py (the same for one run), extract_frames.py (every camera frame as JPEG or PNG, at 20 or 10 fps) and make_overview_video.py (a side-by-side video of the three cameras with the sound and the labels, for viewing).

License

CC BY 4.0. The simulation environment includes two vehicle models under CC BY 4.0: “Police car” by SpatialNeglect and “Ambulance” by RCC Design (Fab), modified.

Citation

If you use SAVAV, please cite it as follows (the reference will be completed after the review of the accompanying paper):

@misc{savav2026,
  title        = {SAVAV: simulated audio-visual recordings of road vehicles around an ego vehicle},
  author       = {Anonymous},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/datasets/AnonymAccount/SAVAV}}
}

Downloads last month: 350

Total file size:

385 GB