# VDM Sample Footage — 2018-09-23

**Package:** `vdm-sample-footage-20180923`
**Version:** 1.0.0
**Capture date:** 2018-09-23
**Contents:** 3 video files, 5,979,013,911 bytes (5.57 GiB) total

> **These are large files.** The payload is roughly 5.6 GiB and each individual
> file is just under 2 GiB. Copying and checksum verification each take several
> minutes on a spinning disk. Plan for a 6.5 GB free-space budget and do not run
> the installer over a slow network share unless you have time to spare.

## What this is

Three synchronized camera channels from a single two-hour capture session
recorded on 2018-09-23. Each file is one camera's full-length recording of the
same scene over the same wall-clock window.

## What it is for

This is the standard sample/reference input for the **VideoDistanceMarking**
project. It exists so that:

- Distance-marking and calibration work can be developed and demonstrated
  against a known, fixed input rather than ad-hoc recordings.
- Results are reproducible — every developer and test machine measures against
  byte-identical footage, verified by SHA256.
- Multi-camera behavior can be exercised, since all three channels cover the
  same scene and timeline.

It is sample data, not production capture output. Nothing here should be
treated as authoritative measurement ground truth unless a calibration
reference is published separately.

## Technical specifications

Every file shares the same encoding parameters:

| Property | Value |
|---|---|
| Container | MP4 |
| Video codec | H.264 (AVC) |
| Profile | High 4:4:4 Predictive |
| Pixel format | `yuv444p` |
| Resolution | 1920 × 1080 |
| Frame rate | 60 fps |
| Duration | 7200.00 s (2 hours) |
| Frame count | 432,000 |
| Average bitrate | ~2.22 Mbit/s |
| Audio | None (no audio stream) |

Per-file details:

| Filename | Camera | Bytes | SHA256 (first 16) |
|---|---|---|---|
| `capture_20180923_0_432000.mp4` | 0 | 1,997,000,959 | `861f269c67eb0f78…` |
| `capture_20180923_1_432000.mp4` | 1 | 1,993,842,258 | `bf2b2ab7babab72e…` |
| `capture_20180923_2_432000.mp4` | 2 | 1,988,170,694 | `c0eb73fe7722cdf8…` |

Full checksums are in [`SHA256SUMS.txt`](SHA256SUMS.txt); machine-readable
metadata is in [`manifest.json`](manifest.json).

### Filename convention

```
capture_<YYYYMMDD>_<cameraIndex>_<frameCount>.mp4
```

The middle numeric field is the camera/channel index (`0`, `1`, `2`); the
trailing field is the total frame count (`432000`).

## Disk space requirement

| | |
|---|---|
| Payload size | 5,979,013,911 bytes (5.57 GiB) |
| **Required free space** | **6.5 GB** on the destination volume |

The installer checks free space *before* copying anything and aborts if the
target volume has less than 6.5 GB available. The headroom above the raw
payload size covers filesystem overhead and allocation slack.

If you are installing from a package on the same volume as the destination,
budget for both copies (~11.2 GiB) until you delete the source.

## Downloading

The footage is published as **loose files** — there is no zip or split archive.
Download each file individually from:

```
https://thehansens.com/tournament/vdm/install/
```

### Browser

Download these six files into a single folder (for example your `Downloads`
folder), keeping their published names:

- `capture_20180923_0_432000.mp4`
- `capture_20180923_1_432000.mp4`
- `capture_20180923_2_432000.mp4`
- `SHA256SUMS.txt`
- `Install-SampleFootage.ps1`
- `manifest.json`

The three `.mp4` files are just under 2 GiB each, so expect a long download and
make sure your browser is not configured to discard large downloads.

### curl (Windows PowerShell, Linux, macOS)

```bash
BASE=https://thehansens.com/tournament/vdm/install
curl -O $BASE/capture_20180923_0_432000.mp4
curl -O $BASE/capture_20180923_1_432000.mp4
curl -O $BASE/capture_20180923_2_432000.mp4
curl -O $BASE/SHA256SUMS.txt
curl -O $BASE/Install-SampleFootage.ps1
```

Use `curl -C -` in place of `curl -O` to resume a partial download — worth it at
this file size:

```bash
curl -C - -O $BASE/capture_20180923_0_432000.mp4
```

On Windows, call `curl.exe` explicitly (in PowerShell, bare `curl` is an alias
for `Invoke-WebRequest`, which takes different arguments):

```powershell
$base = 'https://thehansens.com/tournament/vdm/install'
foreach ($f in @('capture_20180923_0_432000.mp4',
                 'capture_20180923_1_432000.mp4',
                 'capture_20180923_2_432000.mp4',
                 'SHA256SUMS.txt',
                 'Install-SampleFootage.ps1')) {
    curl.exe -L -O "$base/$f"
}
```

**Always verify after downloading** — see [Verifying checksums](#verifying-checksums).
A truncated or proxy-mangled download is the most likely failure mode at this
size, and the checksums are what catch it.

## Installing

The default destination is `C:\VDM\CapturedVideos`, matching the `C:\VDM\`
install root used by the deployment runbook.

If you downloaded the files to a folder, point the installer at that folder with
`-SourcePath`:

```powershell
.\Install-SampleFootage.ps1 -SourcePath $HOME\Downloads
```

### Using the installer script (recommended)

From the package directory:

```powershell
# Dry run first — reports every action, copies nothing
.\Install-SampleFootage.ps1 -WhatIf

# Install to the default location (C:\VDM\CapturedVideos)
.\Install-SampleFootage.ps1

# Install somewhere else
.\Install-SampleFootage.ps1 -DestinationPath D:\VDM\CapturedVideos

# Install from a folder of downloaded files (or any other copy)
.\Install-SampleFootage.ps1 -SourcePath $HOME\Downloads

# Re-verify an existing install; copies nothing
.\Install-SampleFootage.ps1 -VerifyOnly

# Force a re-copy even if the installed files already verify
.\Install-SampleFootage.ps1 -Force
```

The script creates the destination if needed, copies each file with progress
reporting, then verifies every copy against `SHA256SUMS.txt` and prints
`PASS`/`FAIL` per file. It is idempotent — files that already match their
recorded checksum are skipped unless you pass `-Force`.

If PowerShell blocks the script under its execution policy, either unblock the
file or run it for the current process only:

```powershell
Unblock-File .\Install-SampleFootage.ps1
# or
powershell -ExecutionPolicy Bypass -File .\Install-SampleFootage.ps1
```

**Exit codes**

| Code | Meaning |
|---|---|
| `0` | Success — all files verified |
| `1` | One or more files failed verification or are missing |
| `2` | Fatal error — bad arguments, insufficient disk space, unreadable source |

### Manual copy

```powershell
New-Item -ItemType Directory -Force -Path C:\VDM\CapturedVideos
Copy-Item .\capture_20180923_*_432000.mp4 -Destination C:\VDM\CapturedVideos
```

Then verify using the instructions below. Do not skip verification after a
manual copy — silent truncation on a full disk is the common failure mode with
files this size.

## Verifying checksums

### Windows (PowerShell)

Easiest route — let the installer do it:

```powershell
.\Install-SampleFootage.ps1 -VerifyOnly -DestinationPath C:\VDM\CapturedVideos
```

Manual equivalent, comparing against `SHA256SUMS.txt`:

```powershell
$dir = 'C:\VDM\CapturedVideos'
Get-Content .\SHA256SUMS.txt | ForEach-Object {
    $expected, $name = $_ -split '\s+', 2
    $path = Join-Path $dir $name.Trim()
    if (-not (Test-Path $path)) { "MISSING  $name"; return }
    $actual = (Get-FileHash $path -Algorithm SHA256).Hash.ToLower()
    if ($actual -eq $expected.ToLower()) { "PASS  $name" } else { "FAIL  $name" }
}
```

To hash a single file:

```powershell
Get-FileHash C:\VDM\CapturedVideos\capture_20180923_0_432000.mp4 -Algorithm SHA256
```

Note that `Get-FileHash` prints uppercase hex while `SHA256SUMS.txt` stores
lowercase; compare case-insensitively.

### Linux / macOS

`SHA256SUMS.txt` uses the standard two-space `<hash>  <filename>` format with
LF line endings, so it works directly with `sha256sum`:

```bash
cd /path/to/footage
sha256sum -c SHA256SUMS.txt
```

Expected output:

```
capture_20180923_0_432000.mp4: OK
capture_20180923_1_432000.mp4: OK
capture_20180923_2_432000.mp4: OK
```

On macOS, use `shasum -a 256 -c SHA256SUMS.txt` if `sha256sum` is unavailable.

## Package contents

| File | Purpose |
|---|---|
| `README.md` | This document |
| `manifest.json` | Machine-readable package and per-file metadata |
| `SHA256SUMS.txt` | Checksums in `sha256sum` format |
| `Install-SampleFootage.ps1` | Installer / verifier |
| `capture_20180923_*_432000.mp4` | The footage payload (3 files) |

These are distributed as **loose files** — there is no archive to unpack. All of
them are published at
<https://thehansens.com/tournament/vdm/install/> alongside the
VideoDistanceMarking software installer.

`Install-SampleFootage.ps1`, `SHA256SUMS.txt` and `manifest.json` can be
downloaded on their own if you only need to verify an existing install.