disable segment + camera + boot data logging

We don't use comma's upload/replay pipeline, and the segment recorder
was silently filling /data with 30 MB rlog files per minute (the 64 GB
we just cleared). Disable the writers entirely.

- process_config.py: comment out loggerd, encoderd, stream_encoderd
- manager.py: skip save_bootlog() at manager init (was writing
  boot info to /data/media/0/realdata/boot/<bootid>/)

deleter still runs for cleanup of any leftover data; logmessaged still
runs (in-memory log routing IPC). uploader was already disabled in
baseline. No process consumes loggerd/encoderd output onroad, so this
is purely a sink removal.

.gitignore

@@ -2,8 +2,6 @@ prebuilt
 system/clearpilot/dev/on_start_brian.sh
 system/clearpilot/dev/id_rsa
 system/clearpilot/dev/id_rsa.pub
-system/clearpilot/dev/id_ed25519
-system/clearpilot/dev/id_ed25519.pub
 venv/
 .venv/
 .ci_cache

CANBUS_ISSUE_INVESTIGATE.md

@@ -1,29 +0,0 @@
-# CAN-FD Issues to Investigate
-
-## Cruise Control Desync on Hot Start
-
-### Problem
-When the car is already in cruise control mode before openpilot starts (or before controlsd initializes), pressing the cruise control button causes a desync:
-
-1. Car has active cruise control when openpilot comes online
-2. Driver presses cruise button — car interprets as "toggle off" (cruise was already on)
-3. openpilot interprets it as "engage" (from its perspective, it hasn't seen a cruise enable transition)
-4. Result: car disengages cruise, but openpilot thinks it just engaged lateral mode
-
-### Proposed Fix
-When controlsd first reads carState and discovers `cruiseState.enabled` is already true:
-
-1. Set a flag `cruise_was_active_at_start = True`
-2. While this flag is set, do NOT allow openpilot to transition to engaged state on button press
-3. Only clear the flag after seeing `cruiseState.enabled` go to `False` at least once (a full stop of cruise, not just standstill/pause)
-4. After the first full off cycle, normal engagement logic resumes
-
-### Status
-- Could not reproduce on 2026-04-14 — may require specific timing (openpilot restart while driving with cruise active)
-- Need to capture telemetry data during reproduction to see exact signal sequence
-- Key telemetry groups to watch: `cruise` (enabled, available, ACCMode, VSetDis), `buttons` (cruise_button)
-
-### Relevant Code
-- `selfdrive/controls/controlsd.py` — engagement state machine
-- `selfdrive/car/hyundai/carstate.py` — CAN-FD cruise state parsing
-- `selfdrive/car/interfaces.py` — pcm_enable / cruise state transitions

CLAUDE.md

@@ -2,27 +2,100 @@
 
 ## Project Overview
 
-ClearPilot is a custom fork of **FrogPilot** (itself a fork of comma.ai's openpilot), based on a 2024 release. It is purpose-built for Brian Hanson's **Hyundai Tucson** (HDA2 equipped). The vehicle's HDA2 system has specific quirks around how it synchronizes driving state with openpilot that require careful handling.
+ClearPilot is a custom fork of **FrogPilot** (itself a fork of comma.ai's openpilot), purpose-built for Brian Hanson's **Hyundai Tucson** (HDA2 equipped). The vehicle's HDA2 system has specific quirks around how it synchronizes driving state with openpilot that require careful handling.
 
-### Key Customizations in This Fork
+The fork was previously in a state where many features were layered on top but the driving model behavior had regressed in ways that couldn't be traced. On **2026-05-03** the working tree was reset back to a known-clean baseline so features can be re-introduced one at a time with proper testing.
 
-- **UI changes** to the onroad driving interface
-- **Lane change behavior**: brief disengage when turn signal is active during lane changes
-- **Lateral control disabled**: the car's own radar cruise control handles lateral; openpilot handles longitudinal only
-- **Driver monitoring timeouts**: modified safety timeouts for the driver monitoring system
-- **Custom driving models**: `duck-amigo.thneed`, `farmville.onnx`, `wd-40.thneed` in `selfdrive/clearpilot/models/`
-- **ClearPilot service**: Node.js service at `selfdrive/clearpilot/` with behavior scripts for lane change and longitudinal control
-- **Native dashcamd**: C++ process capturing raw camera frames via VisionIPC with OMX H.264 hardware encoding
-- **Standstill power saving**: model inference throttled to 1fps and fan quieted when car is stopped
-- **ClearPilot menu**: sidebar settings panel replacing stock home screen (Home, Dashcam, Debug panels)
-- **Status window**: live system stats (temp, fan, storage, RAM, WiFi, VPN, GPS, telemetry status)
-- **Debug button (LFA)**: steering wheel button repurposed for screen toggle and future UI actions
-- **Telemetry system**: diff-based CSV logger via ZMQ IPC, toggleable from Debug panel
-- **Bench mode**: `--bench` flag for onroad UI testing without car connected
-- **GPS**: custom AT-command based GPS daemon (`system/clearpilot/gpsd.py`) replacing broken qcomgpsd diag interface
-- **OpenVPN tunnel**: auto-connecting VPN to expose device on remote network for SSH access
+## Current State (post-reset)
 
-See `GOALS.md` for feature roadmap.
+This tree currently contains:
+
+- **The pristine pre-modification baseline** (commit `c2ab0fa`, "reset to pre-modification baseline").
+- **Startup-chain customizations** (commit `5624898`): launch scripts, on_start/provision flow, OpenVPN auto-connect, nice-monitor, build helpers, custom logo + spinner, encrypted dev SSH keys.
+- **Build/launch fixes** (commit `b287fd0`, tagged `working-baseline-2`): make baseline compile cleanly (QtWebEngine removed; `screenDisplayMode` reference fixed), and make `build_only.sh` exit on failure with a detached error window.
+
+`build_only.sh` succeeds and `launch_openpilot.sh` boots the full manager process set.
+
+## Where the Old Code Lives
+
+| Location | What it is |
+|---|---|
+| `/data/openpilot/` | This repo. Working baseline + startup port. **Active.** |
+| `/data/openpilot-broken-2026-05-03/` | Full snapshot (with `.git`) of the prior modified-but-broken tree. Reference for porting features. |
+| `/data/clearpilot-baseline/` | The original baseline source we copied in. Kept for safety; do not modify. |
+| `/data/openpilot-features-broken/` | Pre-existing snapshot from an earlier reset attempt — **unverified**, leave alone. |
+
+| Tag | Commit | What |
+|---|---|---|
+| `pre-reset-2026-05-03` | `f7e602c` | Last commit of the broken-but-feature-complete tree. |
+| `working-baseline-2` | `b287fd0` | Current head after the reset + startup port + compile fixes. |
+
+Both tags are pushed to `origin/clearpilot`.
+
+## Pending Feature Port Roadmap
+
+Everything below is present in `/data/openpilot-broken-2026-05-03/` and **not** in this tree. Port them in small, testable batches — one feature area per commit, build + launch test in between.
+
+**Driving behavior (HDA2 specifics):**
+- Lateral disabled (car's radar cruise handles steering; openpilot longitudinal only)
+- Brief disengage when turn signal is active during lane changes
+- Driver-monitoring timeout adjustments
+- Custom driving models in `selfdrive/clearpilot/models/`: `duck-amigo.thneed`, `farmville.onnx`, `wd-40.thneed`
+
+**Onroad UI:**
+- Onroad layout changes (number positions, sidebar hidden during drive)
+- New ready/splash screen and home/offroad menu (the "ClearPilot menu" — sidebar settings panel replacing stock home; General / Network / Dashcam / Debug panels)
+- Status window with live system stats (temp, fan, storage, RAM, WiFi, VPN, GPS, telemetry, dashcam)
+- Crash handler in UI with stack-trace dump for SIGSEGV/SIGABRT
+- Display modes via the LFA steering-wheel button (`ScreenDisplayMode`: auto-normal, nightrider, manual normal, screen off, manual nightrider) — including auto day/night switching driven by GPS sunrise/sunset
+
+**Speed / cruise logic:**
+- `selfdrive/clearpilot/speed_logic.py` — speed-limit display, cruise-vs-limit warning signs (different thresholds above/below 50 mph), ding sound on warning transitions
+- New params: `ClearpilotSpeedDisplay`, `ClearpilotSpeedLimitDisplay`, `ClearpilotCruiseWarning`, `ClearpilotPlayDing`, etc.
+
+**Dashcam:**
+- `selfdrive/clearpilot/dashcamd` (native C++) — VisionIPC frames → OMX H.264 hardware encoder, 3-min MP4 segments + SRT GPS subtitles in `/data/media/0/videos/`
+- Trip lifecycle (waits for time + GPS + drive gear; closes on park/ignition off)
+- `system/loggerd/deleter.py` trip-aware storage rotation
+- Disables `encoderd` / `stream_encoderd`; reuses upstream `omx_encoder.cc`
+
+**GPS:**
+- `system/clearpilot/gpsd.py` — replacement for broken `qcomgpsd` diag interface; polls Quectel modem via `mmcli` AT commands at 1Hz, publishes `gpsLocation`
+- NOAA solar-position calc for sunrise/sunset (drives display auto day/night)
+
+**Telemetry:**
+- `selfdrive/clearpilot/telemetry.py` (client) + `telemetryd.py` (collector) — diff-based CSV logger over ZMQ
+- Toggleable via `TelemetryEnabled` memory param from Debug panel
+- Auto-disabled if `/data` free < 5 GB; auto-disabled on every manager start
+- Hyundai CAN-FD data logged from `selfdrive/car/hyundai/carstate.py update_canfd()`
+
+**Bench mode (UI testing without a car):**
+- `--bench` flag → `BENCH_MODE=1` → enables `bench_onroad.py`, blocks real car processes
+- `bench_cmd.py` for setting fake vehicle state via params
+- UI introspection RPC at `ipc:///tmp/clearpilot_ui_rpc` (widget-tree dump)
+
+**Power/thermal:**
+- Standstill power saving: `modeld` and `dmonitoringmodeld` throttled to 1fps when stopped
+- Fan controller uses offroad clamps at standstill
+- Park CPU savings + virtual battery shutdown fix
+
+**Memory params (`/dev/shm/params`):**
+Lots of new keys for runtime UI state — `TelemetryEnabled`, `VpnEnabled`, `ModelStandby`, `ScreenDisplayMode`, `DashcamState`, `DashcamFrames`, `DashcamShutdown`, `LogDirInitialized`, plus the speed/cruise display set.
+
+**Session logging:**
+- `/data/log2/current/` per-process stderr capture; aggregate `session.log` of major events
+- Time-resolved log dir rename via GPS/NTP; 30-day rotation
+- See `selfdrive/manager/process.py` and `manager.py` changes
+
+**Already in this tree (just listing for reference, do NOT re-port):**
+- `system/clearpilot/vpn-monitor.sh` + `vpn.ovpn` — OpenVPN auto-connect to `vpn.hanson.xyz`
+- `system/clearpilot/nice-monitor.sh`
+- `system/clearpilot/provision.sh` (apt installs, Claude Code installer, git remote fix, fast-forward)
+- `system/clearpilot/on_start.sh` (SSH keys, ssh.service, git.hanson.xyz Host config, WiFi radio on)
+- `system/clearpilot/dev/id_ed25519.{cpt,pub.cpt}` (DongleId-keyed)
+- `system/clearpilot/startup_logo/bg.jpg` + scripts
+- `selfdrive/ui/qt/spinner` + `spinner.cc/.h` (custom logo)
+- `build_only.sh`, `build_preflight.sh`
 
 ## Working Rules
 
@@ -37,6 +110,20 @@ This is self-driving software. All changes must be deliberate and well-understoo
 - **Test everything thoroughly** — Brian must always be in the loop
 - **Do not refactor, clean up, or "improve" code beyond the specific request**
 
+### Logging
+
+**NEVER use `cloudlog`.** It's comma.ai's cloud telemetry pipeline, not ours — writes go to a publisher that's effectively a black hole for us (and the only thing it could do if ever reachable is bother the upstream FrogPilot developer). Our changes must always use **file logging** instead.
+
+Use `print(..., file=sys.stderr, flush=True)`. `manager.py` redirects each managed process's stderr to `/data/log2/current/{process}.log` (once that feature is re-ported), so these lines land in the per-process log we already grep. Prefix custom log lines with `CLP ` so they're easy to filter out from upstream noise.
+
+Example:
+```python
+import sys
+print(f"CLP frogpilotPlan valid=False: carState_freq_ok={sm.freq_ok['carState']}", file=sys.stderr, flush=True)
+```
+
+Do not use `cloudlog.warning`, `cloudlog.info`, `cloudlog.error`, `cloudlog.event`, or `cloudlog.exception` in any CLEARPILOT-added code. Existing upstream/FrogPilot `cloudlog` calls can stay untouched.
+
 ### File Ownership
 
 We operate as `root` on this device, but openpilot runs as the `comma` user (uid=1000, gid=1000). After any code changes that touch multiple files or before testing:
@@ -50,6 +137,7 @@ chown -R comma:comma /data/openpilot
 - Remote: `git@git.hanson.xyz:brianhansonxyz/clearpilot.git`
 - Branch: `clearpilot`
 - Large model files are tracked in git (intentional — this is a backup)
+- The `clearpilot` branch was force-pushed on 2026-05-03 as part of the reset; the prior history is reachable via the `pre-reset-2026-05-03` tag.
 
 ### Samba Share
 
@@ -62,453 +150,92 @@ chown -R comma:comma /data/openpilot
 
 ### Testing Changes
 
-Always use `build_only.sh` to compile, then start the manager separately. Never compile individual targets with scons directly — always use the full build script. Always use full paths with `su - comma` — the login shell drops into `/home/comma` (volatile tmpfs), not `/data/openpilot`. **Always start the manager after a successful build** — don't wait for the user to ask.
+Use `build_only.sh` to compile, then start the manager separately. Never compile individual targets with scons directly — always use the full build script. Always start the manager after a successful build — don't wait for the user to ask.
 
 ```bash
-# 1. Fix ownership (we edit as root, openpilot runs as comma)
+# 1. Fix ownership
 chown -R comma:comma /data/openpilot
 
 # 2. Build (kills running manager, removes prebuilt, compiles, exits)
-#    Shows progress spinner on screen. On failure, shows error on screen
-#    and prints to stderr. Does NOT start the manager.
+#    build_only.sh tees output to /tmp/build.log and propagates the build's
+#    exit code via PIPESTATUS. On failure: error text window stays on screen
+#    fully detached; the script exits non-zero and stderr has the compile error.
 su - comma -c "bash /data/openpilot/build_only.sh"
 
 # 3. If build succeeded ($? == 0), start openpilot
 su - comma -c "bash /data/openpilot/launch_openpilot.sh"
 
-# 4. Review the aggregate session log for errors
-cat /data/log2/current/session.log
-
-# 5. Check per-process stdout/stderr logs if needed
+# 4. Inspect logs
 ls /data/log2/current/
-cat /data/log2/current/gpsd.log
+cat /data/log2/current/session.log
 ```
 
 ### Adding New Params
 
-The params system uses a C++ whitelist. Adding a new param name in `manager.py` alone will crash with `UnknownKeyName`. You must:
+The params system uses a C++ whitelist. Adding a new param name without registering it will crash with `UnknownKeyName`. To add one:
 
 1. Register the key in `common/params.cc` (alphabetically, with `PERSISTENT` or `CLEAR_ON_*` flag)
-2. Add the default value in `selfdrive/manager/manager.py` in `manager_init()`
+2. Set the default in `selfdrive/manager/manager.py` `manager_init()`
 3. Remove `prebuilt`, `common/params.o`, and `common/libcommon.a` to force rebuild
 
 ### Memory Params (paramsMemory)
 
-ClearPilot uses memory params (`/dev/shm/params/d/`) for UI toggles that should reset on boot. Key rules:
+Once re-ported, ClearPilot will use memory params (`/dev/shm/params/d/`) for UI toggles that should reset on boot. Conventions:
 
-- **Registration**: Register the key in `common/params.cc` as `PERSISTENT` (same as FrogPilot pattern — the registration flag does NOT control which path the param lives at)
-- **C++ access**: Use `Params{"/dev/shm/params"}` — stored as a class member `paramsMemory` in onroad.h. Do NOT use `Params("/dev/shm/params/d")` — the Params class appends `/d/` internally, so that would resolve to `/dev/shm/params/d/d/`
-- **Python access**: Use `Params("/dev/shm/params")`
-- **Defaults**: Set in `manager_init()` via `Params("/dev/shm/params").put(key, value)`
-- **UI toggles**: Use `ToggleControl` with manual `toggleFlipped` lambda that writes via `Params("/dev/shm/params")`. Do NOT use `ParamControl` for memory params — it reads/writes persistent params only
-- **Current memory params**: `TelemetryEnabled` (default "0"), `VpnEnabled` (default "1"), `ModelStandby` (default "0"), `ScreenDisplayMode`
-- **IMPORTANT — method names differ between C++ and Python**: C++ uses camelCase (`putBool`, `getBool`, `getInt`), Python uses snake_case (`put_bool`, `get_bool`, `get_int`). This is a common source of silent failures — the wrong casing compiles/runs but doesn't work.
+- **Registration**: register in `common/params.cc` as `PERSISTENT` (the registration flag does NOT control which path the param lives at)
+- **C++ access**: `Params{"/dev/shm/params"}` — the Params class appends `/d/` internally, so `Params("/dev/shm/params/d")` would resolve to `/dev/shm/params/d/d/`
+- **Python access**: `Params("/dev/shm/params")`
+- **UI toggles**: use `ToggleControl` with manual `toggleFlipped` lambda, not `ParamControl` (which only handles persistent params)
+- **IMPORTANT — method names differ between C++ and Python**: C++ uses camelCase (`putBool`, `getBool`, `getInt`), Python uses snake_case (`put_bool`, `get_bool`, `get_int`). This is a common source of silent failures.
 
-### Building Native (C++) Processes
+### Changing a Service's Publish Rate
 
-- SCons is the build system. Static libraries (`common`, `messaging`, `cereal`, `visionipc`) must be imported as SCons objects, not `-l` flags
-- The `--as-needed` linker flag can cause link order issues with static libs — disable it in your SConscript if needed
-- OMX encoder object (`omx_encoder.o`) is compiled by the UI build — reference the pre-built `.o` file rather than recompiling (avoids "two environments" scons error)
-- `prebuilt` is recreated after every successful build — always remove it before rebuilding
-
-## Bench Mode (Onroad UI Testing)
-
-Bench mode allows testing the onroad UI without a car connected. It runs a fake vehicle simulator (`bench_onroad.py`) as a managed process and disables real car processes (pandad, thermald, controlsd, etc.).
-
-### Usage
-
-**IMPORTANT**: Do NOT use `echo` to write bench params — `echo` appends a newline which causes param parsing to fail silently (e.g. gear stays in park). Always use the `bench_cmd.py` tool.
-
-```bash
-# 1. Build first
-chown -R comma:comma /data/openpilot
-su - comma -c "bash /data/openpilot/build_only.sh"
-
-# 2. Start in bench mode
-su - comma -c "bash /data/openpilot/launch_openpilot.sh --bench"
-
-# 3. Wait for UI to be ready (polls RPC every 1s, up to 20s)
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd wait_ready"
-
-# 4. Control vehicle state
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd gear D"
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd speed 20"
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd speedlimit 45"
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd cruise 55"
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd engaged 1"
-
-# 5. Inspect UI widget tree (RPC call, instant response)
-su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_cmd dump"
-```
-
-### Debugging Crashes
-
-The UI has a SIGSEGV/SIGABRT crash handler (`selfdrive/ui/main.cc`) that prints a stack trace to stderr, captured in the per-process log:
-
-```bash
-# Check for crash traces (use /data/log2/current which is always the active session)
-grep -A 30 "CRASH" /data/log2/current/ui.log
-
-# Resolve addresses to source lines
-addr2line -e /data/openpilot/selfdrive/ui/ui -f 0xADDRESS
-
-# bench_cmd dump detects crash loops automatically:
-# if UI process uptime < 5s, it reports "likely crash looping"
-
-# Check per-process logs
-ls /data/log2/current/
-cat /data/log2/current/session.log
-cat /data/log2/current/gpsd.log
-```
-
-### UI Introspection RPC
-
-The UI process runs a ZMQ REP server at `ipc:///tmp/clearpilot_ui_rpc`. Send `"dump"` to get a recursive widget tree showing class name, visibility, geometry, and stacked layout current indices. This is the primary debugging tool for understanding what the UI is displaying.
-
-- `bench_cmd dump` — queries the RPC and prints the widget tree
-- `bench_cmd wait_ready` — polls the RPC every second until `ReadyWindow` is visible (up to 10s)
-- `ui_dump.py` — standalone dump tool (same as `bench_cmd dump`)
-
-### Architecture
-
-- `launch_openpilot.sh --bench` sets `BENCH_MODE=1` env var
-- `manager.py` reads `BENCH_MODE`, blocks real car processes, enables `bench_onroad` process
-- `bench_onroad.py` publishes fake `pandaStates` (ignition=true), `carState`, `controlsState` — thermald reads the fake pandaStates to determine ignition and publishes `deviceState.started=true` on its own
-- thermald and camerad run normally in bench mode (thermald manages CPU cores needed for camerad)
-- Blocked processes in bench mode: pandad, controlsd, radard, plannerd, calibrationd, torqued, paramsd, locationd, sensord, ubloxd, pigeond, dmonitoringmodeld, dmonitoringd, modeld, soundd, loggerd, micd, dashcamd
-
-### Key Files
-
-| File | Role |
-|------|------|
-| `selfdrive/clearpilot/bench_onroad.py` | Fake vehicle state publisher |
-| `selfdrive/clearpilot/bench_cmd.py` | Command tool for setting bench params and querying UI |
-| `selfdrive/clearpilot/ui_dump.py` | Standalone UI widget tree dump |
-| `selfdrive/manager/process_config.py` | Registers bench_onroad as managed process (enabled=BENCH_MODE) |
-| `selfdrive/manager/manager.py` | Blocks conflicting processes in bench mode |
-| `launch_openpilot.sh` | Accepts `--bench` flag, exports BENCH_MODE env var |
-| `selfdrive/ui/qt/window.cc` | UI RPC server (`ipc:///tmp/clearpilot_ui_rpc`), widget tree dump |
-
-### Resolved Issues
-
-- **SIGSEGV in onroad view (fixed)**: `update_model()` in `ui.cc` dereferenced empty model position data when modeld wasn't running. Fixed by guarding against empty `plan_position.getX()`. The root cause was found using the crash handler + `addr2line`.
-- **`showDriverView` overriding transitions (fixed)**: was forcing `slayout` to onroad/home every frame at 20Hz, overriding park/drive logic. Fixed to only act when not in started state.
-- **Sidebar appearing during onroad transition (fixed)**: `MainWindow::closeSettings()` was re-enabling the sidebar. Fixed by not calling `closeSettings` during `offroadTransition`.
-
-## Session Logging
-
-Per-process stderr and an aggregate event log are captured in `/data/log2/current/`.
-
-### Log Directory
-
-- `/data/log2/current/` is always the active session directory
-- `init_log_dir()` is called once from `manager_init()` — creates a fresh `/data/log2/current/` real directory
-- If a previous `current/` real directory exists (unresolved session), it's renamed using its mtime timestamp
-- If a previous `current` symlink exists, it's removed
-- Once system time is valid (GPS/NTP), the real directory is renamed to `/data/log2/YYYY-MM-DD-HH-MM-SS/` and `current` becomes a symlink to it
-- `LogDirInitialized` param: `"0"` until time resolves, then `"1"`
-- Open file handles survive the rename (same inode, same filesystem)
-- Session directories older than 30 days are deleted on manager startup
-
-### Per-Process Logs
-
-- Every `PythonProcess` and `NativeProcess` has stderr redirected to `{name}.log` in the session directory
-- `DaemonProcess` (athenad) redirects both stdout+stderr (existing behavior)
-- Stderr is redirected via `os.dup2` inside the forked child process
-
-### Aggregate Session Log (`session.log`)
-
-A single `session.log` in each session directory records major events:
-
-- Manager start/stop/crash
-- Process starts, deaths (with exit codes), watchdog restarts
-- Onroad/offroad transitions
-
-### Key Files
-
-| File | Role |
-|------|------|
-| `selfdrive/manager/process.py` | Log directory creation, stderr redirection, session_log logger |
-| `selfdrive/manager/manager.py` | Log rotation cleanup, session event logging |
-| `build_only.sh` | Build-only script (no manager start) |
-
-## Dashcam (dashcamd)
-
-### Architecture
-
-`dashcamd` is a native C++ process that captures raw camera frames directly from `camerad` via VisionIPC and encodes to MP4 using the Qualcomm OMX H.264 hardware encoder. This replaces the earlier FrogPilot screen recorder approach (`QWidget::grab()` -> OMX).
-
-- **Codec**: H.264 AVC (hardware accelerated via `OMX.qcom.video.encoder.avc`)
-- **Resolution**: 1928x1208 (full camera resolution, no downscaling)
-- **Bitrate**: 2500 kbps
-- **Container**: MP4 (remuxed via libavformat) + SRT subtitle sidecar
-- **Segment length**: 3 minutes per file
-- **Save path**: `/data/media/0/videos/YYYYMMDD-HHMMSS/YYYYMMDD-HHMMSS.mp4` (trip directories)
-- **GPS subtitles**: companion `.srt` file per segment with 1Hz entries (speed MPH, lat/lon, UTC timestamp)
-- **Trip lifecycle**: starts recording on launch with 10-min idle timer; car in drive cancels timer; park/off restarts timer; ignition cycle = new trip
-- **Graceful shutdown**: thermald sets `DashcamShutdown` param, dashcamd closes segment and acks within 15s
-- **Storage**: ~56 MB per 3-minute segment at 2500 kbps
-- **Storage device**: WDC SDINDDH4-128G UFS 2.1 — automotive grade, ~384 TB write endurance, no concern for continuous writes
-
-### Key Differences from Old Screen Recorder
-
-| | Old (screen recorder) | New (dashcamd) |
-|---|---|---|
-| Source | `QWidget::grab()` screen capture | Raw NV12 from VisionIPC |
-| Resolution | 1440x720 | 1928x1208 |
-| Works with screen off | No (needs visible widget) | Yes (independent of UI) |
-| Process type | Part of UI process | Standalone native process |
-| Encoder input | RGBA -> NV12 conversion | NV12 direct (added `encode_frame_nv12`) |
-
-### Key Files
-
-| File | Role |
-|------|------|
-| `selfdrive/clearpilot/dashcamd.cc` | Main dashcam process — VisionIPC -> OMX encoder |
-| `selfdrive/clearpilot/SConscript` | Build config for dashcamd |
-| `selfdrive/frogpilot/screenrecorder/omx_encoder.cc` | OMX encoder (added `encode_frame_nv12` method) |
-| `selfdrive/frogpilot/screenrecorder/omx_encoder.h` | Encoder header |
-| `selfdrive/manager/process_config.py` | dashcamd registered as NativeProcess, camerad always_run, encoderd disabled |
-| `system/loggerd/deleter.py` | Trip-aware storage rotation (oldest trip first, then segments within active trip) |
-
-### Params
-
-- `DashcamDebug` — when `"1"`, dashcamd runs even without car connected (for bench testing)
-- `DashcamShutdown` — set by thermald before power-off, dashcamd acks by clearing it
-
-## Standstill Power Saving
-
-When `carState.standstill` is true:
-
-- **modeld**: skips GPU inference on 19/20 frames (1fps vs 20fps), reports 0 frame drops to avoid triggering `modeldLagging` in controlsd
-- **dmonitoringmodeld**: same 1fps throttle, added `carState` subscription
-- **Fan controller**: uses offroad clamps (0-30%) instead of onroad (30-100%) at standstill; thermal protection still active via feedforward if temp > 60°C
-
-### Key Files
-
-| File | Role |
-|------|------|
-| `selfdrive/modeld/modeld.py` | Standstill frame skip logic |
-| `selfdrive/modeld/dmonitoringmodeld.py` | Standstill frame skip logic |
-| `selfdrive/thermald/fan_controller.py` | Standstill-aware fan clamps |
-| `selfdrive/thermald/thermald.py` | Passes standstill to fan controller via carState |
-
-## Display Modes (LFA/LKAS Debug Button)
-
-The Hyundai Tucson's LFA steering wheel button cycles through 5 display modes via `ScreenDisplayMode` param (`/dev/shm/params`, CLEAR_ON_MANAGER_START, default 0).
-
-### Display States
-
-| State | Name | Display | Camera | Path Drawing |
-|-------|------|---------|--------|-------------|
-| 0 | auto-normal | on | yes | filled (normal) |
-| 1 | auto-nightrider | on | black | 2px outline only |
-| 2 | normal (manual) | on | yes | filled (normal) |
-| 3 | screen off | GPIO off | n/a | n/a |
-| 4 | nightrider (manual) | on | black | 2px outline only |
-
-### Auto Day/Night Switching
-
-- `gpsd.py` computes `is_daylight(lat, lon, utc_dt)` using NOAA solar position algorithm
-- First calculation immediately on GPS fix + valid clock, then every 30 seconds
-- State 0 + sunset → auto-switch to 1; State 1 + sunrise → auto-switch to 0
-- States 2/3/4 are never touched by auto logic
-- `IsDaylight` param written to `/dev/shm/params` for reference
-
-### Button Behavior
-
-**Onroad (car in drive gear):** 0→4, 1→2, 2→3, 3→4, 4→2 (never back to auto via button)
-
-**Not in drive (parked/off):** any except 3 → 3 (screen off), state 3 → 0 (auto-normal)
-
-### Nightrider Mode
-
-- Camera feed suppressed (OpenGL clears to black instead of rendering camera texture)
-- All HUD elements (speed, alerts, telemetry indicator) still visible
-- Path/lane polygons drawn as 2px outlines only (no gradient fill)
-- Lane lines, road edges, blind spot paths, adjacent paths all use outline rendering
-
-### Signal Chain
-
-```
-Steering wheel LFA button press
-  -> CAN-FD: cruise_btns_msg_canfd["LFA_BTN"]
-  -> Edge detection → ButtonEvent(type=FrogPilotButtonType.lkas)
-  -> controlsd.clearpilot_state_control()
-     -> Reads ScreenDisplayMode, applies transition table based on driving_gear
-     -> Writes new ScreenDisplayMode to /dev/shm/params
-  -> UI reads ScreenDisplayMode in paintEvent() (for camera/nightrider)
-     and drawHud() (for display power on/off)
-```
-
-### Key Files
-
-| File | Role |
-|------|------|
-| `selfdrive/controls/controlsd.py` | Button state machine, writes ScreenDisplayMode |
-| `selfdrive/ui/qt/onroad.cc` | Nightrider rendering, display power control |
-| `selfdrive/ui/qt/home.cc` | Display power for park/splash state |
-| `system/clearpilot/gpsd.py` | Sunset/sunrise calc, auto day/night transitions |
-| `selfdrive/clearpilot/bench_cmd.py` | `debugbutton` command simulates button press |
-
-## Screen Timeout / Display Power
-
-Display power is managed by `Device::updateWakefulness()` in `selfdrive/ui/ui.cc`.
-
-- **Ignition off (offroad)**: screen blanks after `ScreenTimeout` seconds (default 120) of no touch. Tapping wakes it.
-- **Ignition on (onroad)**: screen stays on unconditionally — ignition=true short-circuits the timeout check.
-- **Debug button (LFA)**: cycles through display modes including screen off (state 3). Only state 3 calls `Hardware::set_display_power(false)`.
-
-## Offroad UI (ClearPilot Menu)
-
-The offroad home screen (`selfdrive/ui/qt/home.cc`) is a sidebar settings panel replacing the stock home screen. The original system settings are no longer accessible — the ClearPilot menu is the only settings interface.
-
-### Panels
-
-- **General**: Status window, Reset Calibration, Shutdown Timer, Reboot/Soft Reboot/Power Off
-- **Network**: WiFi management, tethering, roaming, hidden networks (APN settings removed)
-- **Dashcam**: placeholder for future dashcam footage viewer
-- **Debug**: Telemetry logging toggle
-
-### Navigation
-
-- Tapping the splash screen (ReadyWindow) opens the ClearPilot menu
-- "← Back" button returns to splash or onroad view
-- Sidebar with stock metrics (TEMP, VEHICLE, CONNECT) is hidden
+SubMaster's `freq_ok` check requires observed rate to fall within `[0.8 × min_freq, 1.2 × max_freq]` of the value declared in `cereal/services.py`. Publishing *faster* than declared trips `commIssue` just as surely as too slow. If you change how often a process publishes, update the rate in `cereal/services.py` to match.
 
 ## Device: comma 3x
 
-### Hardware
-
-- Qualcomm Snapdragon SoC (aarch64)
-- Serial: comma-3889765b
+- Qualcomm Snapdragon SoC (aarch64), serial `comma-3889765b`
 - Storage: WDC SDINDDH4-128G, 128 GB UFS 2.1
-- Connects to the car via comma panda (CAN bus interface)
+- Ubuntu 20.04.6 LTS on AGNOS 9.7
+- Kernel 4.9.103+ (custom comma.ai PREEMPT build, vendor-patched Qualcomm)
+- Python 3.11.4 via pyenv at `/usr/local/pyenv/versions/3.11.4/` (system python 3.8 — do not use)
+- Display: Weston (Wayland) on tty1
+- Hardware encoding: OMX (`OMX.qcom.video.encoder.avc` / `.hevc`); V4L2 VIDC exists but is not usable from ffmpeg subprocess
 
-### Operating System
+### Filesystem mount quirks
 
-- **Ubuntu 20.04.6 LTS (Focal Fossa)** on aarch64
-- **Kernel**: 4.9.103+ (custom comma.ai PREEMPT build, Feb 2024) — very old, vendor-patched Qualcomm kernel
-- **Python**: 3.11.4 via pyenv at `/usr/local/pyenv/versions/3.11.4/` (system python is 3.8, do not use)
-- **AGNOS version**: 9.7 (comma's custom OS layer on top of Ubuntu)
-- **Display server**: Weston (Wayland compositor) on tty1
-- **SELinux**: mounted (enforcement status varies)
+| Mount | Device | Type | Notes |
+|---|---|---|---|
+| `/` | /dev/sda7 | ext4 | rw |
+| `/data` | /dev/sda12 | ext4 | **persistent** — openpilot lives here |
+| `/home` | overlay | overlayfs | **volatile** (upper on tmpfs) — changes lost on reboot |
+| `/tmp` | tmpfs | tmpfs | volatile |
+| `/persist` | /dev/sda2 | ext4 | persistent config/certs, noexec |
+| `/dsp` | /dev/sde26 | ext4 | **read-only** Qualcomm DSP firmware |
+| `/firmware` | /dev/sde4 | vfat | **read-only** firmware blobs |
 
-### Users
+### GPS
 
-- `comma` (uid=1000) — the user openpilot runs as; member of root, sudo, disk, gpu, gpio groups
-- `root` — what we SSH in as; files must be chowned back to comma before running openpilot
-
-### Filesystem / Mount Quirks
-
-| Mount       | Device      | Type    | Notes |
-|-------------|-------------|---------|-------|
-| `/`         | /dev/sda7   | ext4    | Root filesystem, read-write |
-| `/data`     | /dev/sda12  | ext4    | **Persistent**. Openpilot lives here. Survives reboots. |
-| `/home`     | overlay     | overlayfs | **VOLATILE** — upperdir on tmpfs, changes lost on reboot |
-| `/tmp`      | tmpfs       | tmpfs   | Volatile, 150 MB |
-| `/var`      | tmpfs       | tmpfs   | Volatile, 128 MB (fstab) / 1.5 GB (actual) |
-| `/systemrw` | /dev/sda10  | ext4    | Writable system overlay, noexec |
-| `/persist`  | /dev/sda2   | ext4    | Persistent config/certs, noexec |
-| `/cache`    | /dev/sda11  | ext4    | Android-style cache partition |
-| `/dsp`      | /dev/sde26  | ext4    | **Read-only** Qualcomm DSP firmware |
-| `/firmware`  | /dev/sde4   | vfat    | **Read-only** firmware blobs |
-
-### Hardware Encoding
-
-- **OMX**: `OMX.qcom.video.encoder.avc` (H.264) and `OMX.qcom.video.encoder.hevc` — used by dashcamd and screen recorder
-- **V4L2**: Qualcomm VIDC at `/dev/v4l/by-path/platform-aa00000.qcom_vidc-video-index1` — used by encoderd (now disabled). Not accessible from ffmpeg due to permission/driver issues
-- **ffmpeg**: v4.2.2, has `h264_v4l2m2m` and `h264_omx` listed but neither works from ffmpeg subprocess (OMX port issues, V4L2 device not found). Use OMX directly via the C++ encoder
-
-### Fan Control
-
-Software-controlled via `thermald` -> `fan_controller.py` -> panda USB -> PWM. Target temp 70°C, PI+feedforward controller. See Standstill Power Saving section for standstill-aware clamps.
+The device has **no u-blox chip** (`/dev/ttyHS0` does not exist). GPS is the **Quectel EC25 LTE modem**'s built-in GPS, accessed via AT commands through `mmcli`. The original `qcomgpsd` is broken on this device because the diag interface hangs after setup. Once re-ported, `system/clearpilot/gpsd.py` replaces it.
 
 ## Boot Sequence
 
 ```
 Power On
-  -> systemd: comma.service (runs as comma user)
-    -> /usr/comma/comma.sh (waits for Weston, handles factory reset)
-      -> /data/continue.sh (exec bridge to openpilot)
-        -> /data/openpilot/launch_openpilot.sh
-          -> Kills other instances of itself and manager.py
-          -> Runs on_start.sh (logo, reverse SSH)
-          -> exec launch_chffrplus.sh
-            -> Sources launch_env.sh (thread counts, AGNOS_VERSION)
-            -> Runs agnos_init (marks boot slot, GPU perms, checks OS update)
-            -> Sets PYTHONPATH, symlinks /data/pythonpath
-            -> Runs build.py if no `prebuilt` marker
-            -> Launches selfdrive/manager/manager.py
-              -> manager_init() sets default params
-              -> ensure_running() loop starts all managed processes
+  → systemd: comma.service (runs as comma user)
+    → /usr/comma/comma.sh (waits for Weston, handles factory reset)
+      → /data/continue.sh
+        → /data/openpilot/launch_openpilot.sh
+          → kill stale instances (launch_openpilot, launch_chffrplus, manager.py, ./ui, selfdrive/ui/text)
+          → bash system/clearpilot/on_start.sh  (SSH, WiFi, run provision.sh)
+          → background system/clearpilot/vpn-monitor.sh
+          → background system/clearpilot/nice-monitor.sh
+          → exec ./launch_chffrplus.sh
+            → source launch_env.sh
+            → run agnos_init
+            → set PYTHONPATH
+            → if no `prebuilt`: run build.py (spinner + scons)
+            → exec selfdrive/manager/manager.py
+              → manager_init() sets default params
+              → ensure_running() loop starts managed processes
 ```
-
-## Openpilot Architecture
-
-### Process Manager
-
-`selfdrive/manager/manager.py` orchestrates all processes defined in `selfdrive/manager/process_config.py`.
-
-### Always-Running Processes (offroad + onroad)
-
-- `thermald` — thermal management and fan control
-- `pandad` — panda CAN bus interface
-- `ui` — Qt-based onroad/offroad UI
-- `deleter` — storage cleanup (9 GB threshold)
-- `statsd`, `timed`, `logmessaged`, `tombstoned` — telemetry/logging
-- `manage_athenad` — comma cloud connectivity
-- `fleet_manager`, `frogpilot_process` — FrogPilot additions
-
-### Onroad-Only Processes (when driving)
-
-- `controlsd` — main vehicle control loop
-- `plannerd` — path planning
-- `radard` — radar processing
-- `modeld` — driving model inference (throttled to 1fps at standstill)
-- `dmonitoringmodeld` — driver monitoring model (throttled to 1fps at standstill)
-- `locationd`, `calibrationd`, `paramsd`, `torqued` — localization and calibration
-- `sensord` — IMU/sensor data
-- `soundd` — alert sounds
-- `camerad` — camera capture
-- `loggerd` — CAN/sensor log recording (video encoding disabled)
-
-### ClearPilot Processes
-
-- `dashcamd` — raw camera dashcam recording (runs onroad or with DashcamDebug flag)
-
-### GPS
-
-- Device has **no u-blox chip** (`/dev/ttyHS0` does not exist) — `ubloxd`/`pigeond` never start
-- GPS hardware is a **Quectel EC25 LTE modem** (USB, `lsusb: 2c7c:0125`) with built-in GPS
-- GPS is accessed via AT commands through `mmcli`: `mmcli -m any --command='AT+QGPSLOC=2'`
-- **`qcomgpsd`** (original openpilot process) uses the modem's diag interface which is broken on this device — the diag recv loop blocks forever after setup. Commented out.
-- **`system/clearpilot/gpsd.py`** is the replacement — polls GPS via AT commands at 1Hz, publishes `gpsLocation` cereal messages
-- GPS data flows: `gpsd` → `gpsLocation` → `locationd` → `liveLocationKalman` → `timed` (sets system clock)
-- `locationd` checks `UbloxAvailable` param (false on this device) to subscribe to `gpsLocation` instead of `gpsLocationExternal`
-- `mmcli` returns `response: '...'` wrapper — `at_cmd()` strips it before parsing (fixed)
-- GPS antenna power must be enabled via GPIO: `gpio_set(GPIO.GNSS_PWR_EN, True)`
-- System `/usr/sbin/gpsd` daemon may respawn and interfere — should be disabled or killed
-
-### Telemetry
-
-- **Client**: `selfdrive/clearpilot/telemetry.py` — `tlog(group, data)` sends JSON over ZMQ PUSH
-- **Collector**: `selfdrive/clearpilot/telemetryd.py` — diffs against previous state, writes changed values to CSV
-- **Toggle**: `TelemetryEnabled` memory param, controlled from Debug panel in ClearPilot menu
-- **Auto-disable**: disabled on every manager start; disabled if `/data` free < 5GB
-- **Hyundai CAN-FD data**: logged from `selfdrive/car/hyundai/carstate.py` `update_canfd()` — groups: `car`, `cruise`, `speed_limit`, `buttons`
-- **GPS data**: logged directly by telemetryd via cereal `gpsLocation` subscription at 1Hz — group: `gps` (latitude, longitude, speed, altitude, bearing, accuracy)
-- **CSV location**: `/data/log2/current/telemetry.csv` (or session directory)
-- **Onroad overlay**: when telemetry enabled, status bar shows temp, fan %, model FPS, and STANDSTILL indicator
-- **Speed limit**: `speed_limit.calculated` is the final computed speed limit value (in vehicle units, MPH when `is_metric=False`). This is the value that will be used for the future speed limit warning chime feature
-
-### Key Dependencies
-
-- **Python 3.11** (via pyenv) with: numpy, casadi, onnx/onnxruntime, pycapnp, pyzmq, sentry-sdk, sympy, Cython
-- **capnp (Cap'n Proto)** — IPC message serialization between all processes
-- **ZeroMQ** — IPC transport layer
-- **Qt 5** — UI framework (with WebEngine available but not used for rotation reasons)
-- **OpenMAX (OMX)** — hardware video encoding
-- **libavformat** — MP4 container muxing
-- **libyuv** — color space conversion
-- **SCons** — build system for native C++ components

DASHCAM_PROJECT.md

@@ -1,49 +0,0 @@
-# Dashcam Project
-
-## Status
-
-### Completed (2026-04-11)
-
-- Disabled comma training data video encoding (`encoderd`) — CAN/sensor logs still recorded
-- Re-enabled FrogPilot OMX screen recorder (H.264 MP4, 1440x720, 2Mbps, hardware encoded)
-- Auto-start/stop recording tied to car ignition (`scene.started`)
-- `ScreenRecorderDebug` param for bench testing without car connected
-- Hidden all recorder UI elements — invisible to driver
-- Videos saved to `/data/media/0/videos/YYYYMMDD-HHMMSS.mp4`, 3-minute segments
-- Deleter updated: 9 GB free space threshold, rotates oldest videos first
-- Cleaned up offroad UI: replaced stock home screen with grid launcher (Settings + Dashcam buttons)
-
-### Next: Dashcam Footage Viewer
-
-Build a native Qt widget accessible from the offroad home screen "Dashcam" button.
-
-**Requirements:**
-- List MP4 files from `/data/media/0/videos/` sorted newest first
-- Tap a file to play it back using Qt Multimedia (`QMediaPlayer` + `QVideoWidget`)
-- Only accessible when offroad (car in park or off)
-- Back button to return to offroad home
-- No rotation hacks needed — native Qt widget in existing UI tree handles rotation correctly
-
-**Architecture:**
-- New widget class (e.g. `DashcamViewer`) added to `selfdrive/ui/qt/`
-- Wire into `HomeWindow`'s `QStackedLayout` alongside `home`, `onroad`, `ready`, `driver_view`
-- Dashcam button in `OffroadHome` switches `slayout` to the viewer
-- Viewer has a file list view and a playback view (sub-stacked layout)
-- Back button returns to `OffroadHome`
-- Build: add to `qt_src` list in `selfdrive/ui/SConscript`, link `Qt5Multimedia`
-
-**Previous webview attempts (abandoned):**
-- Brian tried QWebEngineView for browser-based playback but the WebEngine subprocess renders independently of Qt's widget tree
-- Screen rotation (`view.rotate(90)`, Wayland `wl_surface_set_buffer_transform`) did not work for WebEngine content
-- Native Qt widget approach avoids this problem entirely
-
-## Key Files
-
-| File | Role |
-|------|------|
-| `selfdrive/frogpilot/screenrecorder/screenrecorder.cc` | Recording logic, auto-start/stop |
-| `selfdrive/frogpilot/screenrecorder/omx_encoder.cc` | OMX H.264 hardware encoder |
-| `selfdrive/ui/qt/onroad.cc` | Timer driving frame capture |
-| `selfdrive/ui/qt/home.cc` | Offroad home with Dashcam button |
-| `system/loggerd/deleter.py` | Storage rotation |
-| `/data/media/0/videos/` | Video output directory |

GOALS.md

@@ -1,46 +0,0 @@
-# ClearPilot — Feature Goals
-
-Each goal below will be discussed in detail before implementation. Background and specifics to be provided by Brian when we get to each item.
-
-## Dashcam
-
-- [ ] **Dashcam viewer** — on-screen Qt widget for browsing and playing back recorded footage from the offroad home screen (Dashcam button already placed). See `DASHCAM_PROJECT.md` for architecture notes.
-- [ ] **Dashcam uploader** — upload footage to a remote server or cloud storage
-- [ ] **GPS + speed overlay on dashcam footage** — embed GPS coordinates and vehicle speed into the video stream or as metadata
-- [ ] **Dashcam footage archive** — option to mark a trip's footage as archived (kept in storage but hidden from the main UI)
-- [ ] **Suspend dashcam / route recording** — on-screen setting to pause recording for a trip and delete footage of the current trip so far (privacy mode)
-
-## Driving Alerts & Safety
-
-- [ ] **Chirp on speed change and over speed limit** — audible alert when speed limit changes or vehicle exceeds the limit
-- [ ] **Warn on traffic standstill ahead** — alert when approaching cars ahead too quickly (closing distance warning)
-- [ ] **On-screen current speed limit** — display the speed limit as reported by the car's CAN data
-- [ ] **Fix on-screen speed value for MPH** — correct the speed display to use the proper value for MPH conversion
-
-## Cruise Control & Driving State
-
-- [ ] **Auto-set speed via CAN bus** — simulate pressing speed up/down buttons on CAN bus to automatically set cruise to the correct speed via UI interaction (stretch goal)
-- [ ] **Fix engaged-while-braking state sync** — if openpilot is engaged while brakes are pressed, the system thinks it's active but the car isn't actually in cruise control, causing a sync error that should be recoverable
-- [ ] **Fix resume-cruise lateral mode bug** — pressing resume cruise control (rather than enable) causes the car to enter a state where it thinks it's in always-on lateral mode and disables driver monitoring
-- [ ] **Lateral assist in turn lanes** — keep lateral assist active when using turn signal in a turn lane (at low/turning speeds) as opposed to cruising speeds, where lateral currently disengages
-
-## Driver Monitoring
-
-- [ ] **Disable driver monitoring on demand** — add a technique to disable DM for 2 minutes via a button or gesture
-- [ ] **Hands-on-wheel mode** — add a setting requiring the driver to keep hands on the wheel (configurable via settings)
-
-## UI Modes & Display
-
-- [ ] **Curves-only UI mode** — show only on-screen curve/path depictions without the camera feed (reduces visual clutter, saves processing)
-- [ ] **Night mode auto-display-off** — turn off display if device starts at night (determine sunset for current location/datetime or use ambient light levels from car sensors)
-- [ ] **Update boot/offroad splash logos** — replace the red pac-man ghost with a blue pac-man ghost for boot and offroad full-screen splash
-- [ ] **Dashcam-only reboot mode** — on-screen option to reboot into a mode that provides no driver assist (reverts to stock OEM lane assist) but keeps dashcam running. For lending the car to friends who shouldn't use comma's driving features.
-
-## Connectivity & Data
-
-- [ ] **Offroad weather report screen** — weather display accessible from the offroad home grid (depends on internet connection)
-- [ ] **Fix GPS tracking** — GPS tracking feature currently broken, processes commented out in process_config
-
-## Vehicle-Specific (Hyundai Tucson HDA2)
-
-- [ ] **Warn if panoramic roof is open** — if possible to intercept window/roof state from CAN bus, warn when the top roof is left open when the car is turned off

body/board/SConscript

@@ -121,7 +121,6 @@ def objcopy(source, target, env, for_signature):
     return '$OBJCOPY -O binary %s %s' % (source[0], target[0])
 
 # Common autogenerated includes
-os.makedirs("obj", exist_ok=True)
 git_ver = get_version(BUILDER, BUILD_TYPE)
 with open("obj/gitversion.h", "w") as f:
   f.write(f'const uint8_t gitversion[8] = "{git_ver}";\n')

build_only.sh

@@ -35,4 +35,6 @@ source "$BASEDIR/build_preflight.sh"
 cd "$BASEDIR/selfdrive/manager"
 rm -f "$BASEDIR/prebuilt"
 
-BUILD_ONLY=1 exec ./build.py
+# Tee output to /tmp/build.log for inspection after the script exits
+BUILD_ONLY=1 ./build.py 2>&1 | tee /tmp/build.log
+exit "${PIPESTATUS[0]}"

common/params.cc

@@ -109,8 +109,6 @@ std::unordered_map<std::string, uint32_t> keys = {
     {"ControlsReady", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
     {"CurrentBootlog", PERSISTENT},
     {"CurrentRoute", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
-    {"DashcamDebug", PERSISTENT},
-    {"DashcamShutdown", CLEAR_ON_MANAGER_START},
     {"DisableLogging", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
     {"DisablePowerDown", PERSISTENT},
     {"DisableUpdates", PERSISTENT},
@@ -160,7 +158,6 @@ std::unordered_map<std::string, uint32_t> keys = {
     {"LastUpdateTime", PERSISTENT},
     {"LiveParameters", PERSISTENT},
     {"LiveTorqueParameters", PERSISTENT | DONT_LOG},
-    {"LogDirInitialized", CLEAR_ON_MANAGER_START},
     {"LongitudinalPersonality", PERSISTENT},
     {"NavDestination", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
     {"NavDestinationWaypoints", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
@@ -195,13 +192,9 @@ std::unordered_map<std::string, uint32_t> keys = {
     {"SnoozeUpdate", CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION},
     {"SshEnabled", PERSISTENT},
     {"TermsVersion", PERSISTENT},
-    {"TelemetryEnabled", PERSISTENT},
     {"Timezone", PERSISTENT},
     {"TrainingVersion", PERSISTENT},
-    {"ModelStandby", PERSISTENT},
-    {"ModelStandbyTs", PERSISTENT},
     {"UbloxAvailable", PERSISTENT},
-    {"VpnEnabled", PERSISTENT},
     {"UpdateAvailable", CLEAR_ON_MANAGER_START | CLEAR_ON_ONROAD_TRANSITION},
     {"UpdateFailedCount", CLEAR_ON_MANAGER_START},
     {"UpdaterAvailableBranches", PERSISTENT},
@@ -217,13 +210,6 @@ std::unordered_map<std::string, uint32_t> keys = {
 
     // FrogPilot parameters
     {"AccelerationPath", PERSISTENT},
-    {"BenchCruiseActive", CLEAR_ON_MANAGER_START},
-    {"BenchCruiseSpeed", CLEAR_ON_MANAGER_START},
-    {"ClpUiState", CLEAR_ON_MANAGER_START},
-    {"BenchEngaged", CLEAR_ON_MANAGER_START},
-    {"BenchGear", CLEAR_ON_MANAGER_START},
-    {"BenchSpeed", CLEAR_ON_MANAGER_START},
-    {"BenchSpeedLimit", CLEAR_ON_MANAGER_START},
     {"AccelerationProfile", PERSISTENT},
     {"AdjacentPath", PERSISTENT},
     {"AdjacentPathMetrics", PERSISTENT},
@@ -251,23 +237,12 @@ std::unordered_map<std::string, uint32_t> keys = {
     
     {"CarSpeedLimitWarning", PERSISTENT},
     {"CarSpeedLimitLiteral", PERSISTENT},
-    {"CarIsMetric", PERSISTENT},
-
-    {"ClearpilotSpeedDisplay", PERSISTENT},
-    {"ClearpilotSpeedLimitDisplay", PERSISTENT},
-    {"ClearpilotHasSpeed", PERSISTENT},
-    {"ClearpilotIsMetric", PERSISTENT},
-    {"ClearpilotSpeedUnit", PERSISTENT},
-    {"ClearpilotCruiseWarning", PERSISTENT},
-    {"ClearpilotCruiseWarningSpeed", PERSISTENT},
-    {"ClearpilotPlayDing", PERSISTENT},
-
+    
     // {"SpeedLimitLatDesired", PERSISTENT},
     // {"SpeedLimitVTSC", PERSISTENT},
 
     {"CPTLkasButtonAction", PERSISTENT},
-    {"IsDaylight", CLEAR_ON_MANAGER_START},
-    {"ScreenDisplayMode", CLEAR_ON_MANAGER_START},
+    {"ScreenDisplayMode", PERSISTENT},
     
     {"RadarDist", PERSISTENT},
     {"ModelDist", PERSISTENT},
@@ -441,7 +416,6 @@ std::unordered_map<std::string, uint32_t> keys = {
     {"ScreenBrightnessOnroad", PERSISTENT},
     {"ScreenManagement", PERSISTENT},
     {"ScreenRecorder", PERSISTENT},
-    {"ScreenRecorderDebug", PERSISTENT},
     {"ScreenTimeout", PERSISTENT},
     {"ScreenTimeoutOnroad", PERSISTENT},
     {"SearchInput", PERSISTENT},

launch_openpilot.sh

@@ -15,6 +15,12 @@ pkill -9 -f './ui' 2>/dev/null
 pkill -9 -f 'selfdrive/ui/text' 2>/dev/null
 sleep 1
 
+# CLEARPILOT: ensure params persistence dir is owned by comma:comma. Editing
+# the tree as root leaves files owned by root in /data/params/d_tmp/, and
+# Params writes done as comma will then EACCES on rename. Reset on every
+# launch so this never silently breaks again.
+sudo chown -R comma:comma /data/params
+
 bash /data/openpilot/system/clearpilot/on_start.sh
 
 # CLEARPILOT: start VPN monitor (kills previous instances, runs as root)

openpilot/clearpiliot_devqueue_zbacklog.txt

@@ -1,7 +1,17 @@
 -----
 
-- screen off on lkas
+- fix debug notice message
+- screen mode 1 = no UI, screen mode 2 = off
 - speed limit change chirp on cruise
+- fix always on detection, change message
+
+-----
+
+- Better debugger and data recorder
+- Represent distance to lead car on primary UI
+- Start testing for alert when stopped traffic and approaching > 31 mph 
+  - or not enough time to slow at 31
+  - special experimental mode override?
 
 -----
 
@@ -11,6 +21,7 @@
 - better turning logic
 - new settings UI
 - experimental mode
+- resume from stop
 
 ------------
 

panda/SConscript

@@ -166,7 +166,6 @@ Export('base_project_f4', 'base_project_h7', 'build_project')
 
 
 # Common autogenerated includes
-os.makedirs("board/obj", exist_ok=True)
 with open("board/obj/gitversion.h", "w") as f:
   f.write(f'const uint8_t gitversion[] = "{get_version(BUILDER, BUILD_TYPE)}";\n')
 

selfdrive/SConscript

@@ -3,5 +3,4 @@ SConscript(['controls/lib/lateral_mpc_lib/SConscript'])
 SConscript(['controls/lib/longitudinal_mpc_lib/SConscript'])
 SConscript(['locationd/SConscript'])
 SConscript(['modeld/SConscript'])
-SConscript(['ui/SConscript'])
-SConscript(['clearpilot/SConscript'])
+SConscript(['ui/SConscript'])

selfdrive/athena/manage_athenad.py

@@ -32,9 +32,7 @@ def main():
         continue
 
       cloudlog.info("starting athena daemon")
-      from openpilot.selfdrive.manager.process import _log_dir
-      log_path = _log_dir + "/athenad.log"
-      proc = Process(name='athenad', target=launcher, args=('selfdrive.athena.athenad', 'athenad', log_path))
+      proc = Process(name='athenad', target=launcher, args=('selfdrive.athena.athenad', 'athenad'))
       proc.start()
       proc.join()
       cloudlog.event("athenad exited", exitcode=proc.exitcode)

selfdrive/car/hyundai/carstate.py

@@ -13,7 +13,6 @@ from openpilot.selfdrive.car.hyundai.hyundaicanfd import CanBus
 from openpilot.selfdrive.car.hyundai.values import HyundaiFlags, CAR, DBC, CAN_GEARS, CAMERA_SCC_CAR, \
                                                    CANFD_CAR, Buttons, CarControllerParams
 from openpilot.selfdrive.car.interfaces import CarStateBase
-from openpilot.selfdrive.clearpilot.telemetry import tlog
 
 PREV_BUTTON_SAMPLES = 8
 CLUSTER_SAMPLE_RATE = 20  # frames
@@ -212,7 +211,6 @@ class CarState(CarStateBase):
 
     # self.params_memory.put_int("CarSpeedLimitLiteral", self.calculate_speed_limit(cp, cp_cam))
     self.params_memory.put_float("CarSpeedLimit", self.calculate_speed_limit(cp, cp_cam) * speed_conv)
-    self.params_memory.put("CarIsMetric", "1" if self.is_metric else "0")
     self.params_memory.put_float("CarCruiseDisplayActual", cp_cruise.vl["SCC11"]["VSetDis"])
     
 
@@ -421,16 +419,6 @@ class CarState(CarStateBase):
     # print(self.calculate_speed_limit(cp, cp_cam))
     # self.params_memory.put_float("CarSpeedLimitLiteral", self.calculate_speed_limit(cp, cp_cam))
     self.params_memory.put_float("CarSpeedLimit", self.calculate_speed_limit(cp, cp_cam) * speed_factor)
-    self.params_memory.put("CarIsMetric", "1" if self.is_metric else "0")
-
-    # CLEARPILOT: telemetry logging — disabled, re-enable when needed
-    # speed_limit_bus = cp if self.CP.flags & HyundaiFlags.CANFD_HDA2 else cp_cam
-    # scc = cp_cam.vl["SCC_CONTROL"] if self.CP.flags & HyundaiFlags.CANFD_CAMERA_SCC else cp.vl["SCC_CONTROL"]
-    # cluster = speed_limit_bus.vl["CLUSTER_SPEED_LIMIT"]
-    # tlog("car", { ... })
-    # tlog("cruise", { ... })
-    # tlog("speed_limit", { ... })
-    # tlog("buttons", { ... })
 
     return ret
 

selfdrive/car/interfaces.py

@@ -484,19 +484,10 @@ class CarInterfaceBase(ABC):
           self.silent_steer_warning = True
           events.add(EventName.steerTempUnavailableSilent)
         else:
-          # CLEARPILOT: log once per instance of this warning
-          if not getattr(self, '_steer_fault_logged', False):
-            import sys
-            print(f"CLP steerTempUnavailable: steerFaultTemporary={cs_out.steerFaultTemporary} "
-                  f"steeringPressed={cs_out.steeringPressed} standstill={cs_out.standstill} "
-                  f"steering_unpressed={self.steering_unpressed} steeringAngleDeg={cs_out.steeringAngleDeg:.1f} "
-                  f"steeringTorque={cs_out.steeringTorque:.1f} vEgo={cs_out.vEgo:.2f}", file=sys.stderr)
-            self._steer_fault_logged = True
           events.add(EventName.steerTempUnavailable)
     else:
       self.no_steer_warning = False
       self.silent_steer_warning = False
-      self._steer_fault_logged = False
     if cs_out.steerFaultPermanent:
       events.add(EventName.steerUnavailable)
 

selfdrive/clearpilot/SConscript

@@ -1,16 +0,0 @@
-Import('env', 'arch', 'common', 'messaging', 'visionipc', 'cereal')
-
-clearpilot_env = env.Clone()
-clearpilot_env['CPPPATH'] += ['#selfdrive/frogpilot/screenrecorder/openmax/include/']
-# Disable --as-needed so static lib ordering doesn't matter
-clearpilot_env['LINKFLAGS'] = [f for f in clearpilot_env.get('LINKFLAGS', []) if f != '-Wl,--as-needed']
-
-if arch == "larch64":
-  omx_obj = File('#selfdrive/frogpilot/screenrecorder/omx_encoder.o')
-  clearpilot_env.Program(
-    'dashcamd',
-    ['dashcamd.cc', omx_obj],
-    LIBS=[common, 'json11', cereal, visionipc, messaging,
-          'zmq', 'capnp', 'kj', 'm', 'OpenCL', 'ssl', 'crypto', 'pthread',
-          'OmxCore', 'avformat', 'avcodec', 'avutil', 'yuv']
-  )

selfdrive/clearpilot/bench_cmd.py

@@ -1,147 +0,0 @@
-#!/usr/bin/env python3
-"""
-ClearPilot bench command tool. Sets bench params and queries UI state.
-
-Usage:
-  python3 -m selfdrive.clearpilot.bench_cmd gear D
-  python3 -m selfdrive.clearpilot.bench_cmd speed 20
-  python3 -m selfdrive.clearpilot.bench_cmd speedlimit 45
-  python3 -m selfdrive.clearpilot.bench_cmd cruise 55
-  python3 -m selfdrive.clearpilot.bench_cmd cruiseactive 0|1|2  (0=disabled, 1=active, 2=paused)
-  python3 -m selfdrive.clearpilot.bench_cmd engaged 1
-  python3 -m selfdrive.clearpilot.bench_cmd ding              (trigger speed limit ding sound)
-  python3 -m selfdrive.clearpilot.bench_cmd debugbutton       (simulate LKAS debug button press)
-  python3 -m selfdrive.clearpilot.bench_cmd dump
-  python3 -m selfdrive.clearpilot.bench_cmd wait_ready
-"""
-import os
-import subprocess
-import sys
-import time
-import zmq
-from openpilot.common.params import Params
-
-
-def check_ui_process():
-  """Check if UI process is running and healthy. Returns error string or None if OK."""
-  try:
-    result = subprocess.run(["pgrep", "-a", "-f", "./ui"], capture_output=True, text=True)
-    if result.returncode != 0:
-      return "ERROR: UI process not running"
-    # Get the PID and check its uptime
-    for line in result.stdout.strip().split("\n"):
-      parts = line.split(None, 1)
-      if len(parts) >= 2 and "./ui" in parts[1]:
-        pid = parts[0]
-        try:
-          stat = os.stat(f"/proc/{pid}")
-          uptime = time.time() - stat.st_mtime
-          if uptime < 5:
-            return f"ERROR: UI process (pid {pid}) uptime {uptime:.1f}s — likely crash looping. Check: tail /data/log2/$(ls -t /data/log2/ | head -1)/session.log"
-        except FileNotFoundError:
-          return "ERROR: UI process disappeared"
-  except Exception:
-    pass
-  return None
-
-
-def ui_dump():
-  ctx = zmq.Context()
-  sock = ctx.socket(zmq.REQ)
-  sock.setsockopt(zmq.RCVTIMEO, 2000)
-  sock.connect("ipc:///tmp/clearpilot_ui_rpc")
-  sock.send_string("dump")
-  try:
-    return sock.recv_string()
-  except zmq.Again:
-    return None
-  finally:
-    sock.close()
-    ctx.term()
-
-
-def wait_ready(timeout=20):
-  """Wait until the UI shows ReadyWindow, up to timeout seconds."""
-  start = time.time()
-  while time.time() - start < timeout:
-    dump = ui_dump()
-    if dump and "ReadyWindow" in dump:
-      # Check it's actually visible
-      for line in dump.split("\n"):
-        if "ReadyWindow" in line and "vis=Y" in line:
-          print("UI ready (ReadyWindow visible)")
-          return True
-    time.sleep(1)
-  print(f"ERROR: UI not ready after {timeout}s")
-  if dump:
-    print(dump)
-  return False
-
-
-def main():
-  if len(sys.argv) < 2:
-    print(__doc__)
-    return
-
-  cmd = sys.argv[1].lower()
-  params = Params("/dev/shm/params")
-
-  param_map = {
-    "gear": "BenchGear",
-    "speed": "BenchSpeed",
-    "speedlimit": "BenchSpeedLimit",
-    "cruise": "BenchCruiseSpeed",
-    "cruiseactive": "BenchCruiseActive",
-    "engaged": "BenchEngaged",
-  }
-
-  if cmd == "dump":
-    ui_status = check_ui_process()
-    if ui_status:
-      print(ui_status)
-    else:
-      result = ui_dump()
-      if result:
-        print(result)
-      else:
-        print("ERROR: UI not responding")
-
-  elif cmd == "wait_ready":
-    wait_ready()
-
-  elif cmd == "ding":
-    params.put("ClearpilotPlayDing", "1")
-    print("Ding triggered")
-
-  elif cmd == "debugbutton":
-    # Simulate LKAS debug button — same state machine as controlsd.clearpilot_state_control()
-    current = params.get_int("ScreenDisplayMode")
-    gear = (params.get("BenchGear") or b"P").decode().strip().upper()
-    in_drive = gear in ("D", "S", "L")
-
-    if in_drive:
-      transitions = {0: 4, 1: 2, 2: 3, 3: 4, 4: 2}
-      new_mode = transitions.get(current, 0)
-    else:
-      new_mode = 0 if current == 3 else 3
-
-    params.put_int("ScreenDisplayMode", new_mode)
-    mode_names = {0: "auto-normal", 1: "auto-nightrider", 2: "normal", 3: "screen-off", 4: "nightrider"}
-    print(f"ScreenDisplayMode: {current} ({mode_names.get(current, '?')}) → {new_mode} ({mode_names.get(new_mode, '?')})"
-          f"  [gear={gear}, in_drive={in_drive}]")
-
-  elif cmd in param_map:
-    if len(sys.argv) < 3:
-      print(f"Usage: bench_cmd {cmd} <value>")
-      return
-    value = sys.argv[2]
-    params.put(param_map[cmd], value)
-    print(f"{param_map[cmd]} = {value}")
-
-  else:
-    print(f"Unknown command: {cmd}")
-    print(__doc__)
-
-
-if __name__ == "__main__":
-  main()

selfdrive/clearpilot/bench_onroad.py

@@ -1,137 +0,0 @@
-#!/usr/bin/env python3
-"""
-ClearPilot bench onroad simulator.
-
-Publishes fake messages to make the UI go onroad and display
-configurable vehicle state. Control values via params in /dev/shm/params:
-
-  BenchSpeed         - vehicle speed in mph (default: 0)
-  BenchSpeedLimit    - speed limit in mph (default: 0, 0=hidden)
-  BenchCruiseSpeed   - cruise set speed in mph (default: 0, 0=not set)
-  BenchCruiseActive  - 0=disabled, 1=active, 2=paused/standstill (default: 0)
-  BenchGear          - P, D, R, N (default: P)
-  BenchEngaged       - 0 or 1, cruise engaged (default: 0)
-
-Usage:
-  su - comma -c "PYTHONPATH=/data/openpilot python3 -m selfdrive.clearpilot.bench_onroad"
-
-To stop: Ctrl+C or kill the process. UI returns to offroad.
-"""
-import time
-
-import cereal.messaging as messaging
-from cereal import log, car
-from openpilot.common.params import Params
-from openpilot.common.conversions import Conversions as CV
-from openpilot.selfdrive.clearpilot.speed_logic import SpeedState
-
-
-def main():
-  params = Params()
-  params_mem = Params("/dev/shm/params")
-
-  # Set defaults
-  params_mem.put("BenchSpeed", "0")
-  params_mem.put("BenchSpeedLimit", "0")
-  params_mem.put("BenchCruiseSpeed", "0")
-  params_mem.put("BenchCruiseActive", "0")
-  params_mem.put("BenchGear", "P")
-  params_mem.put("BenchEngaged", "0")
-
-  # ClearPilot speed processing
-  speed_state = SpeedState()
-
-  # thermald handles deviceState (reads our fake pandaStates for ignition)
-  pm = messaging.PubMaster([
-    "pandaStates", "carState", "controlsState",
-    "driverMonitoringState", "liveCalibration",
-  ])
-
-  print("Bench onroad simulator started")
-  print("Set values in /dev/shm/params/d/Bench*")
-  print("  BenchSpeed=0  BenchSpeedLimit=0  BenchCruiseSpeed=0  BenchGear=P  BenchEngaged=0")
-
-  gear_map = {
-    "P": car.CarState.GearShifter.park,
-    "D": car.CarState.GearShifter.drive,
-    "R": car.CarState.GearShifter.reverse,
-    "N": car.CarState.GearShifter.neutral,
-  }
-
-  frame = 0
-  try:
-    while True:
-      # Read bench params
-      speed_mph = float((params_mem.get("BenchSpeed", encoding="utf-8") or "0").strip())
-      speed_limit_mph = float((params_mem.get("BenchSpeedLimit", encoding="utf-8") or "0").strip())
-      cruise_mph = float((params_mem.get("BenchCruiseSpeed", encoding="utf-8") or "0").strip())
-      gear_str = (params_mem.get("BenchGear", encoding="utf-8") or "P").strip().upper()
-      cruise_active_str = (params_mem.get("BenchCruiseActive", encoding="utf-8") or "0").strip()
-      engaged = (params_mem.get("BenchEngaged", encoding="utf-8") or "0").strip() == "1"
-
-      speed_ms = speed_mph * CV.MPH_TO_MS
-      speed_limit_ms = speed_limit_mph * CV.MPH_TO_MS
-      cruise_ms = cruise_mph * CV.MPH_TO_MS
-      gear = gear_map.get(gear_str, car.CarState.GearShifter.park)
-
-      # Cruise state: 0=disabled, 1=active, 2=paused
-      cruise_active = cruise_active_str == "1"
-      cruise_standstill = cruise_active_str == "2"
-
-      # ClearPilot speed processing (~2 Hz at 10 Hz loop)
-      if frame % 5 == 0:
-        has_speed = speed_mph > 0
-        speed_state.update(speed_ms, has_speed, speed_limit_ms, is_metric=False,
-                           cruise_speed_ms=cruise_ms, cruise_active=cruise_active or cruise_standstill,
-                           cruise_standstill=cruise_standstill)
-
-      # pandaStates — 10 Hz (thermald reads ignition from this)
-      if frame % 1 == 0:
-        dat = messaging.new_message("pandaStates", 1)
-        dat.pandaStates[0].ignitionLine = True
-        dat.pandaStates[0].pandaType = log.PandaState.PandaType.tres
-        pm.send("pandaStates", dat)
-
-      # carState — 10 Hz
-      dat = messaging.new_message("carState")
-      cs = dat.carState
-      cs.vEgo = speed_ms
-      cs.vEgoCluster = speed_ms
-      cs.gearShifter = gear
-      cs.standstill = speed_ms < 0.1
-      cs.cruiseState.available = True
-      cs.cruiseState.enabled = engaged
-      cs.cruiseState.speed = cruise_mph * CV.MPH_TO_MS if cruise_mph > 0 else 0
-      pm.send("carState", dat)
-
-      # controlsState — 10 Hz
-      dat = messaging.new_message("controlsState")
-      ctl = dat.controlsState
-      ctl.vCruise = cruise_mph * 1.60934 if cruise_mph > 0 else 255  # km/h or 255=not set
-      ctl.vCruiseCluster = ctl.vCruise
-      ctl.enabled = engaged
-      ctl.active = engaged
-      pm.send("controlsState", dat)
-
-      # driverMonitoringState — low freq
-      if frame % 10 == 0:
-        dat = messaging.new_message("driverMonitoringState")
-        dat.driverMonitoringState.isActiveMode = True
-        pm.send("driverMonitoringState", dat)
-
-      # liveCalibration — low freq
-      if frame % 50 == 0:
-        dat = messaging.new_message("liveCalibration")
-        dat.liveCalibration.calStatus = log.LiveCalibrationData.Status.calibrated
-        dat.liveCalibration.rpyCalib = [0.0, 0.0, 0.0]
-        pm.send("liveCalibration", dat)
-
-      frame += 1
-      time.sleep(0.1)  # 10 Hz base loop
-
-  except KeyboardInterrupt:
-    print("\nBench simulator stopped")
-
-
-if __name__ == "__main__":
-  main()

selfdrive/clearpilot/dashcamd.cc

@@ -1,396 +0,0 @@
-/*
- * CLEARPILOT dashcamd — records raw camera footage to MP4 using OMX H.264 hardware encoder.
- *
- * Connects to camerad via VisionIPC, receives NV12 frames, and feeds them directly
- * to the Qualcomm OMX encoder. Produces 3-minute MP4 segments organized by trip.
- *
- * Trip directory structure:
- *   /data/media/0/videos/YYYYMMDD-HHMMSS/   (trip directory, named at trip start)
- *     YYYYMMDD-HHMMSS.mp4                    (3-minute segments)
- *
- * Trip lifecycle state machine:
- *
- *   On process start (after time-valid wait):
- *     - Create trip directory, start recording immediately with 10-min idle timer
- *     - If car is already in drive, timer is cancelled and recording continues
- *     - If car stays parked/off for 10 minutes, trip ends
- *
- *   IDLE_TIMEOUT → RECORDING:
- *     - Car enters drive gear before timer expires → cancel timer, resume recording
- *       in the same trip (no new trip directory)
- *
- *   RECORDING → IDLE_TIMEOUT:
- *     - Car leaves drive gear (park, off, neutral) → start 10-minute idle timer,
- *       continue recording frames during the timeout period
- *
- *   IDLE_TIMEOUT → TRIP_ENDED:
- *     - 10-minute timer expires → close segment, trip is over
- *
- *   TRIP_ENDED → RECORDING (new trip):
- *     - Car enters drive gear → create new trip directory, start recording
- *
- *   Any state → (new trip) on ignition off→on:
- *     - Ignition transitions off→on → close current trip if active, create new trip
- *       directory, start recording with 10-min idle timer. This applies even from
- *       TRIP_ENDED — turning the car on always starts a new trip. If the car is in
- *       park after ignition on, the idle timer runs; entering drive cancels it.
- *
- *   Graceful shutdown (DashcamShutdown param):
- *     - thermald sets DashcamShutdown="1" before device power-off
- *     - dashcamd closes current segment, sets DashcamShutdown="0" (ack), exits
- *     - thermald waits up to 15s for ack, then proceeds with shutdown
- *
- *   GPS subtitle track:
- *     - Each .mp4 segment has a companion .srt subtitle file
- *     - Updated at most once per second from gpsLocation cereal messages
- *     - Format: "35 MPH | 44.9216°N 93.3260°W | 2026-04-13 05:19:00 UTC"
- *     - Most players auto-detect .srt files alongside .mp4 files
- */
-
-#include <cstdio>
-#include <ctime>
-#include <string>
-#include <sys/stat.h>
-#include <sys/resource.h>
-#include <unistd.h>
-
-#include "cereal/messaging/messaging.h"
-#include "cereal/visionipc/visionipc_client.h"
-#include "common/params.h"
-#include "common/timing.h"
-#include "common/swaglog.h"
-#include "common/util.h"
-#include "selfdrive/frogpilot/screenrecorder/omx_encoder.h"
-
-const std::string VIDEOS_BASE = "/data/media/0/videos";
-const int SEGMENT_SECONDS = 180;  // 3 minutes
-const int SOURCE_FPS = 20;
-const int CAMERA_FPS = 10;
-const int FRAMES_PER_SEGMENT = SEGMENT_SECONDS * CAMERA_FPS;
-const int BITRATE = 2500 * 1024;  // 2500 kbps
-const double IDLE_TIMEOUT_SECONDS = 600.0;  // 10 minutes
-
-ExitHandler do_exit;
-
-enum TripState {
-  IDLE,           // no trip active, waiting for drive
-  RECORDING,      // actively recording, car in drive
-  IDLE_TIMEOUT,   // car parked/off, recording with 10-min timer
-  TRIP_ENDED,     // trip closed, waiting for next drive
-};
-
-static std::string make_timestamp() {
-  char buf[64];
-  time_t t = time(NULL);
-  struct tm tm = *localtime(&t);
-  snprintf(buf, sizeof(buf), "%04d%02d%02d-%02d%02d%02d",
-           tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-           tm.tm_hour, tm.tm_min, tm.tm_sec);
-  return std::string(buf);
-}
-
-static bool system_time_valid() {
-  time_t t = time(NULL);
-  struct tm tm = *gmtime(&t);
-  return (tm.tm_year + 1900) >= 2024;
-}
-
-static std::string make_utc_timestamp() {
-  char buf[32];
-  time_t t = time(NULL);
-  struct tm tm = *gmtime(&t);
-  snprintf(buf, sizeof(buf), "%04d-%02d-%02d %02d:%02d:%02d UTC",
-           tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-           tm.tm_hour, tm.tm_min, tm.tm_sec);
-  return std::string(buf);
-}
-
-// Format SRT timestamp: HH:MM:SS,mmm
-static std::string srt_time(int seconds) {
-  int h = seconds / 3600;
-  int m = (seconds % 3600) / 60;
-  int s = seconds % 60;
-  char buf[16];
-  snprintf(buf, sizeof(buf), "%02d:%02d:%02d,000", h, m, s);
-  return std::string(buf);
-}
-
-int main(int argc, char *argv[]) {
-  setpriority(PRIO_PROCESS, 0, -10);
-
-  // Ensure base output directory exists
-  mkdir(VIDEOS_BASE.c_str(), 0755);
-
-  // Wait for valid system time so trip/segment names have real timestamps
-  LOGW("dashcamd: waiting for system time");
-  while (!do_exit) {
-    if (system_time_valid()) break;
-    usleep(1000000);  // 1 Hz poll
-  }
-  if (do_exit) return 0;
-  LOGW("dashcamd: system time valid");
-
-  LOGW("dashcamd: started, connecting to camerad road stream");
-  VisionIpcClient vipc("camerad", VISION_STREAM_ROAD, false);
-  while (!do_exit && !vipc.connect(false)) {
-    usleep(100000);
-  }
-  if (do_exit) return 0;
-  LOGW("dashcamd: vipc connected, waiting for valid frame");
-
-  // Wait for a frame with valid dimensions (camerad may still be initializing)
-  VisionBuf *init_buf = nullptr;
-  while (!do_exit) {
-    init_buf = vipc.recv();
-    if (init_buf != nullptr && init_buf->width > 0 && init_buf->height > 0) break;
-    usleep(100000);
-  }
-  if (do_exit) return 0;
-
-  int width = init_buf->width;
-  int height = init_buf->height;
-  int y_stride = init_buf->stride;
-  int uv_stride = y_stride;
-  LOGW("dashcamd: first valid frame %dx%d stride=%d", width, height, y_stride);
-
-  // Subscribe to carState (gear), deviceState (ignition), gpsLocation (subtitles)
-  SubMaster sm({"carState", "deviceState", "gpsLocation"});
-  Params params;
-
-  // Trip state
-  TripState state = IDLE;
-  OmxEncoder *encoder = nullptr;
-  std::string trip_dir;
-  int frame_count = 0;
-  int recv_count = 0;
-  uint64_t segment_start_ts = 0;
-  double idle_timer_start = 0.0;
-
-  // SRT subtitle state
-  FILE *srt_file = nullptr;
-  int srt_index = 0;          // subtitle entry counter (1-based)
-  int srt_segment_sec = 0;    // seconds elapsed in current segment
-  double last_srt_write = 0;  // monotonic time of last SRT write
-
-  // Ignition tracking for off→on detection
-  bool prev_started = false;
-  bool started_initialized = false;
-
-  // Param check throttle (don't hit filesystem every frame)
-  int param_check_counter = 0;
-
-  // Helper: start a new trip with recording + optional idle timer
-  auto start_new_trip = [&]() {
-    // Close existing encoder if any
-    if (encoder) {
-      if (state == RECORDING || state == IDLE_TIMEOUT) {
-        encoder->encoder_close();
-      }
-      delete encoder;
-      encoder = nullptr;
-    }
-
-    trip_dir = VIDEOS_BASE + "/" + make_timestamp();
-    mkdir(trip_dir.c_str(), 0755);
-    LOGW("dashcamd: new trip %s", trip_dir.c_str());
-
-    encoder = new OmxEncoder(trip_dir.c_str(), width, height, CAMERA_FPS, BITRATE, false, false);
-
-    std::string seg_name = make_timestamp();
-    LOGW("dashcamd: opening segment %s", seg_name.c_str());
-    encoder->encoder_open((seg_name + ".mp4").c_str());
-
-    // Open companion SRT file
-    std::string srt_path = trip_dir + "/" + seg_name + ".srt";
-    srt_file = fopen(srt_path.c_str(), "w");
-    srt_index = 0;
-    srt_segment_sec = 0;
-    last_srt_write = 0;
-
-    frame_count = 0;
-    segment_start_ts = nanos_since_boot();
-    state = RECORDING;
-  };
-
-  auto close_trip = [&]() {
-    if (srt_file) { fclose(srt_file); srt_file = nullptr; }
-    if (encoder) {
-      if (state == RECORDING || state == IDLE_TIMEOUT) {
-        encoder->encoder_close();
-        LOGW("dashcamd: segment closed");
-      }
-      delete encoder;
-      encoder = nullptr;
-    }
-    state = TRIP_ENDED;
-    frame_count = 0;
-    idle_timer_start = 0.0;
-    LOGW("dashcamd: trip ended");
-  };
-
-  // Start recording immediately — if the car is in drive, great; if parked/off,
-  // the 10-min idle timer will stop the trip if drive is never detected.
-  start_new_trip();
-  idle_timer_start = nanos_since_boot() / 1e9;
-  state = IDLE_TIMEOUT;
-  LOGW("dashcamd: recording started, waiting for drive (10-min idle timer active)");
-
-  while (!do_exit) {
-    VisionBuf *buf = vipc.recv();
-    if (buf == nullptr) continue;
-
-    // CLEARPILOT: skip frames to match target FPS (SOURCE_FPS -> CAMERA_FPS)
-    recv_count++;
-    if (SOURCE_FPS > CAMERA_FPS && (recv_count % (SOURCE_FPS / CAMERA_FPS)) != 0) continue;
-
-    sm.update(0);
-    double now = nanos_since_boot() / 1e9;
-
-    // Read vehicle state
-    bool started = sm.valid("deviceState") &&
-                   sm["deviceState"].getDeviceState().getStarted();
-    auto gear = sm.valid("carState") ?
-                sm["carState"].getCarState().getGearShifter() :
-                cereal::CarState::GearShifter::UNKNOWN;
-    bool in_drive = (gear == cereal::CarState::GearShifter::DRIVE ||
-                     gear == cereal::CarState::GearShifter::SPORT ||
-                     gear == cereal::CarState::GearShifter::LOW ||
-                     gear == cereal::CarState::GearShifter::MANUMATIC);
-
-    // Detect ignition off→on transition (new ignition cycle = new trip)
-    if (started_initialized && !prev_started && started) {
-      LOGW("dashcamd: ignition on — new cycle");
-      if (state == RECORDING || state == IDLE_TIMEOUT) {
-        close_trip();
-      }
-      // Start recording immediately, idle timer until drive is detected
-      start_new_trip();
-      idle_timer_start = now;
-      state = IDLE_TIMEOUT;
-    }
-    prev_started = started;
-    started_initialized = true;
-
-    // Check for graceful shutdown request (every ~1 second = 20 frames)
-    if (++param_check_counter >= CAMERA_FPS) {
-      param_check_counter = 0;
-      if (params.getBool("DashcamShutdown")) {
-        LOGW("dashcamd: shutdown requested, closing trip");
-        if (state == RECORDING || state == IDLE_TIMEOUT) {
-          close_trip();
-        }
-        params.putBool("DashcamShutdown", false);
-        LOGW("dashcamd: shutdown ack sent, exiting");
-        break;
-      }
-    }
-
-    // State machine transitions
-    switch (state) {
-      case IDLE:
-      case TRIP_ENDED:
-        if (in_drive) {
-          start_new_trip();
-        }
-        break;
-
-      case RECORDING:
-        if (!in_drive) {
-          // Car left drive — start idle timeout
-          idle_timer_start = now;
-          state = IDLE_TIMEOUT;
-          LOGW("dashcamd: car not in drive, starting 10-min idle timer");
-        }
-        break;
-
-      case IDLE_TIMEOUT:
-        if (in_drive) {
-          // Back in drive — cancel timer, resume recording same trip
-          idle_timer_start = 0.0;
-          state = RECORDING;
-          LOGW("dashcamd: back in drive, resuming trip");
-        } else if ((now - idle_timer_start) >= IDLE_TIMEOUT_SECONDS) {
-          // Timer expired — end trip
-          LOGW("dashcamd: idle timeout expired");
-          close_trip();
-        }
-        break;
-    }
-
-    // Only encode frames when we have an active recording
-    if (state != RECORDING && state != IDLE_TIMEOUT) continue;
-
-    // Segment rotation
-    if (frame_count >= FRAMES_PER_SEGMENT) {
-      if (srt_file) { fclose(srt_file); srt_file = nullptr; }
-      encoder->encoder_close();
-
-      std::string seg_name = make_timestamp();
-      LOGW("dashcamd: opening segment %s", seg_name.c_str());
-      encoder->encoder_open((seg_name + ".mp4").c_str());
-
-      std::string srt_path = trip_dir + "/" + seg_name + ".srt";
-      srt_file = fopen(srt_path.c_str(), "w");
-      srt_index = 0;
-      srt_segment_sec = 0;
-      last_srt_write = 0;
-
-      frame_count = 0;
-      segment_start_ts = nanos_since_boot();
-    }
-
-    uint64_t ts = nanos_since_boot() - segment_start_ts;
-
-    // Feed NV12 frame directly to OMX encoder
-    encoder->encode_frame_nv12(buf->y, y_stride, buf->uv, uv_stride, width, height, ts);
-    frame_count++;
-
-    // Write GPS subtitle at most once per second
-    if (srt_file && (now - last_srt_write) >= 1.0) {
-      last_srt_write = now;
-      srt_index++;
-
-      // Read GPS data
-      double lat = 0, lon = 0, speed_ms = 0;
-      bool has_gps = sm.valid("gpsLocation") && sm["gpsLocation"].getGpsLocation().getHasFix();
-      if (has_gps) {
-        auto gps = sm["gpsLocation"].getGpsLocation();
-        lat = gps.getLatitude();
-        lon = gps.getLongitude();
-        speed_ms = gps.getSpeed();
-      }
-
-      double speed_mph = speed_ms * 2.23694;
-      std::string utc = make_utc_timestamp();
-      std::string t_start = srt_time(srt_segment_sec);
-      std::string t_end = srt_time(srt_segment_sec + 1);
-      srt_segment_sec++;
-
-      if (has_gps) {
-        const char *deg = "\xC2\xB0";  // UTF-8 degree sign
-        fprintf(srt_file, "%d\n%s --> %s\n%.0f MPH | %.4f%s%c %.4f%s%c | %s\n\n",
-                srt_index, t_start.c_str(), t_end.c_str(),
-                speed_mph,
-                std::abs(lat), deg, lat >= 0 ? 'N' : 'S',
-                std::abs(lon), deg, lon >= 0 ? 'E' : 'W',
-                utc.c_str());
-      } else {
-        fprintf(srt_file, "%d\n%s --> %s\nNo GPS | %s\n\n",
-                srt_index, t_start.c_str(), t_end.c_str(), utc.c_str());
-      }
-      fflush(srt_file);
-    }
-  }
-
-  // Clean exit
-  if (srt_file) { fclose(srt_file); srt_file = nullptr; }
-  if (encoder) {
-    if (state == RECORDING || state == IDLE_TIMEOUT) {
-      encoder->encoder_close();
-    }
-    delete encoder;
-  }
-  LOGW("dashcamd: stopped");
-
-  return 0;
-}

selfdrive/clearpilot/dashcamd.py

@@ -1,121 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLEARPILOT dashcamd — records raw camera footage to MP4 using hardware H.264 encoder.
-
-Connects directly to camerad via VisionIPC, receives NV12 frames, and pipes them
-to ffmpeg's h264_v4l2m2m encoder. Produces 3-minute MP4 segments in /data/media/0/videos/.
-
-This replaces the FrogPilot screen recorder approach (QWidget::grab -> OMX) with a
-direct camera capture that works regardless of UI state (screen off, alternate modes, etc).
-"""
-import os
-import time
-import subprocess
-import signal
-from pathlib import Path
-from datetime import datetime
-
-from cereal.visionipc import VisionIpcClient, VisionStreamType
-from openpilot.common.params import Params
-from openpilot.common.swaglog import cloudlog
-from openpilot.selfdrive import sentry
-
-PROCESS_NAME = "selfdrive.clearpilot.dashcamd"
-VIDEOS_DIR = "/data/media/0/videos"
-SEGMENT_SECONDS = 180  # 3 minutes
-CAMERA_FPS = 20
-FRAMES_PER_SEGMENT = SEGMENT_SECONDS * CAMERA_FPS
-
-
-def make_filename():
-  return datetime.now().strftime("%Y%m%d-%H%M%S") + ".mp4"
-
-
-def open_encoder(width, height, filepath):
-  """Start an ffmpeg subprocess that accepts raw NV12 on stdin and writes MP4."""
-  cmd = [
-    "ffmpeg", "-y", "-nostdin", "-loglevel", "error",
-    "-f", "rawvideo",
-    "-pix_fmt", "nv12",
-    "-s", f"{width}x{height}",
-    "-r", str(CAMERA_FPS),
-    "-i", "pipe:0",
-    "-c:v", "h264_v4l2m2m",
-    "-b:v", "4M",
-    "-f", "mp4",
-    "-movflags", "+faststart",
-    filepath,
-  ]
-  return subprocess.Popen(cmd, stdin=subprocess.PIPE)
-
-
-def main():
-  sentry.set_tag("daemon", PROCESS_NAME)
-  cloudlog.bind(daemon=PROCESS_NAME)
-
-  os.makedirs(VIDEOS_DIR, exist_ok=True)
-
-  params = Params()
-
-  # Connect to camerad road stream
-  cloudlog.info("dashcamd: connecting to camerad road stream")
-  vipc = VisionIpcClient("camerad", VisionStreamType.VISION_STREAM_ROAD, False)
-  while not vipc.connect(False):
-    time.sleep(0.1)
-
-  width, height = vipc.width, vipc.height
-  # NV12 frame: Y plane (w*h) + UV plane (w*h/2)
-  frame_size = width * height * 3 // 2
-  cloudlog.info(f"dashcamd: connected, {width}x{height}, frame_size={frame_size}")
-
-  frame_count = 0
-  encoder = None
-  lock_path = None
-
-  try:
-    while True:
-      buf = vipc.recv()
-      if buf is None:
-        continue
-
-      # Start new segment if needed
-      if encoder is None or frame_count >= FRAMES_PER_SEGMENT:
-        # Close previous segment
-        if encoder is not None:
-          encoder.stdin.close()
-          encoder.wait()
-          if lock_path and os.path.exists(lock_path):
-            os.remove(lock_path)
-          cloudlog.info(f"dashcamd: closed segment, {frame_count} frames")
-
-        # Open new segment
-        filename = make_filename()
-        filepath = os.path.join(VIDEOS_DIR, filename)
-        lock_path = filepath + ".lock"
-        Path(lock_path).touch()
-
-        cloudlog.info(f"dashcamd: opening segment {filename}")
-        encoder = open_encoder(width, height, filepath)
-        frame_count = 0
-
-      # Write raw NV12 frame to ffmpeg stdin
-      try:
-        encoder.stdin.write(buf.data[:frame_size])
-        frame_count += 1
-      except BrokenPipeError:
-        cloudlog.error("dashcamd: encoder pipe broken, restarting segment")
-        encoder = None
-
-  except (KeyboardInterrupt, SystemExit):
-    pass
-  finally:
-    if encoder is not None:
-      encoder.stdin.close()
-      encoder.wait()
-      if lock_path and os.path.exists(lock_path):
-        os.remove(lock_path)
-    cloudlog.info("dashcamd: stopped")
-
-
-if __name__ == "__main__":
-  main()

selfdrive/clearpilot/speed_logic.py

@@ -1,90 +0,0 @@
-"""
-ClearPilot speed processing module.
-
-Shared logic for converting raw speed and speed limit data into display-ready
-values. Called from controlsd (live mode) and bench_onroad (bench mode).
-
-Reads raw inputs, converts to display units (mph or kph based on car's CAN
-unit setting), detects speed limit changes, and writes results to params_memory
-for the onroad UI to read.
-"""
-import math
-import time
-from openpilot.common.params import Params
-from openpilot.common.conversions import Conversions as CV
-
-
-class SpeedState:
-  def __init__(self):
-    self.params_memory = Params("/dev/shm/params")
-    self.prev_speed_limit = 0
-
-    # Ding state tracking
-    self.last_ding_time = 0.0
-    self.prev_warning = ""
-    self.prev_warning_speed_limit = 0
-
-  def update(self, speed_ms: float, has_speed: bool, speed_limit_ms: float, is_metric: bool,
-             cruise_speed_ms: float = 0.0, cruise_active: bool = False, cruise_standstill: bool = False):
-    """
-    Convert raw m/s values to display-ready strings and write to params_memory.
-    """
-    now = time.monotonic()
-
-    if is_metric:
-      speed_display = speed_ms * CV.MS_TO_KPH
-      speed_limit_display = speed_limit_ms * CV.MS_TO_KPH
-      cruise_display = cruise_speed_ms * CV.MS_TO_KPH
-      unit = "km/h"
-    else:
-      speed_display = speed_ms * CV.MS_TO_MPH
-      speed_limit_display = speed_limit_ms * CV.MS_TO_MPH
-      cruise_display = cruise_speed_ms * CV.MS_TO_MPH
-      unit = "mph"
-
-    speed_int = int(math.floor(speed_display))
-    speed_limit_int = int(round(speed_limit_display))
-    cruise_int = int(round(cruise_display))
-
-    self.prev_speed_limit = speed_limit_int
-
-    # Write display-ready values to params_memory
-    self.params_memory.put("ClearpilotHasSpeed", "1" if has_speed and speed_int > 0 else "0")
-    self.params_memory.put("ClearpilotSpeedDisplay", str(speed_int) if has_speed and speed_int > 0 else "")
-    self.params_memory.put("ClearpilotSpeedLimitDisplay", str(speed_limit_int) if speed_limit_int > 0 else "0")
-    self.params_memory.put("ClearpilotSpeedUnit", unit)
-    self.params_memory.put("ClearpilotIsMetric", "1" if is_metric else "0")
-
-    # Cruise warning logic
-    warning = ""
-    warning_speed = ""
-    cruise_engaged = cruise_active and not cruise_standstill
-
-    if speed_limit_int >= 20 and cruise_engaged and cruise_int > 0:
-      over_threshold = 10 if speed_limit_int >= 50 else 7
-      if cruise_int >= speed_limit_int + over_threshold:
-        warning = "over"
-        warning_speed = str(cruise_int)
-      elif cruise_int <= speed_limit_int - 5:
-        warning = "under"
-        warning_speed = str(cruise_int)
-
-    self.params_memory.put("ClearpilotCruiseWarning", warning)
-    self.params_memory.put("ClearpilotCruiseWarningSpeed", warning_speed)
-
-    # Ding logic: play when warning sign appears or speed limit changes while visible
-    should_ding = False
-    if warning:
-      if not self.prev_warning:
-        # Warning sign just appeared
-        should_ding = True
-      elif speed_limit_int != self.prev_warning_speed_limit:
-        # Speed limit changed while warning sign is visible
-        should_ding = True
-
-    if should_ding and now - self.last_ding_time >= 30:
-      self.params_memory.put("ClearpilotPlayDing", "1")
-      self.last_ding_time = now
-
-    self.prev_warning = warning
-    self.prev_warning_speed_limit = speed_limit_int if warning else 0

selfdrive/clearpilot/telemetry.py

@@ -1,53 +0,0 @@
-"""
-ClearPilot telemetry client library.
-
-Usage from any process:
-  from openpilot.selfdrive.clearpilot.telemetry import tlog
-  tlog("canbus", {"speed": 45.2, "speed_limit": 60})
-
-Sends JSON packets over ZMQ PUSH to telemetryd, which diffs and writes CSV.
-Only sends when TelemetryEnabled memory param is set — zero cost when disabled.
-"""
-import json
-import os
-import time
-import zmq
-
-TELEMETRY_SOCK = "ipc:///tmp/clearpilot_telemetry"
-_PARAM_PATH = "/dev/shm/params/d/TelemetryEnabled"
-
-_ctx = None
-_sock = None
-_last_check = 0
-_enabled = False
-
-
-def tlog(group: str, data: dict):
-  """Log a telemetry packet. Only changed values will be written to CSV by telemetryd."""
-  global _ctx, _sock, _last_check, _enabled
-
-  # Check param at most once per second to avoid filesystem overhead
-  now = time.monotonic()
-  if now - _last_check > 1.0:
-    _last_check = now
-    try:
-      with open(_PARAM_PATH, 'r') as f:
-        _enabled = f.read().strip() == "1"
-    except (FileNotFoundError, IOError):
-      _enabled = False
-
-  if not _enabled:
-    return
-
-  if _sock is None:
-    _ctx = zmq.Context.instance()
-    _sock = _ctx.socket(zmq.PUSH)
-    _sock.setsockopt(zmq.LINGER, 0)
-    _sock.setsockopt(zmq.SNDHWM, 100)
-    _sock.connect(TELEMETRY_SOCK)
-
-  msg = json.dumps({"ts": time.time(), "group": group, "data": data})
-  try:
-    _sock.send_string(msg, zmq.NOBLOCK)
-  except zmq.Again:
-    pass  # drop if collector isn't running or queue full

selfdrive/clearpilot/telemetryd.py

@@ -1,147 +0,0 @@
-#!/usr/bin/env python3
-"""
-ClearPilot telemetry collector.
-
-Receives telemetry packets from any process via ZMQ, diffs against previous
-state per group, and writes only changed values to CSV.
-
-Controlled by TelemetryEnabled param — when toggled on, the first packet
-from each group writes all values (full dump). When toggled off, stops writing.
-
-CSV format: timestamp,group,key,value
-"""
-import csv
-import json
-import os
-import shutil
-import time
-import zmq
-
-import cereal.messaging as messaging
-from openpilot.common.params import Params
-from openpilot.selfdrive.clearpilot.telemetry import TELEMETRY_SOCK
-from openpilot.selfdrive.manager.process import _log_dir, session_log
-
-MIN_DISK_FREE_GB = 5
-DISK_CHECK_INTERVAL = 10  # seconds
-
-
-def main():
-  params = Params("/dev/shm/params")
-  ctx = zmq.Context.instance()
-  sock = ctx.socket(zmq.PULL)
-  sock.setsockopt(zmq.RCVHWM, 1000)
-  sock.bind(TELEMETRY_SOCK)
-
-  # GPS subscriber for location telemetry
-  sm = messaging.SubMaster(['gpsLocation'])
-  last_gps_log = 0
-
-  csv_path = os.path.join(_log_dir, "telemetry.csv")
-  state: dict[str, dict] = {}  # group -> {key: last_value}
-  was_enabled = False
-  writer = None
-  f = None
-  last_disk_check = 0
-
-  while True:
-    # Check enable state every iteration (cheap param read)
-    enabled = params.get("TelemetryEnabled") == b"1"
-
-    # Check disk space every 10 seconds while enabled
-    if enabled and (time.monotonic() - last_disk_check) > DISK_CHECK_INTERVAL:
-      last_disk_check = time.monotonic()
-      disk = shutil.disk_usage("/data")
-      free_gb = disk.free / (1024 ** 3)
-      if free_gb < MIN_DISK_FREE_GB:
-        session_log.warning("telemetry disabled: disk free %.1f GB < %d GB", free_gb, MIN_DISK_FREE_GB)
-        params.put("TelemetryEnabled", "0")
-        enabled = False
-
-    # Toggled on: open CSV, clear state so first packet is a full dump
-    if enabled and not was_enabled:
-      f = open(csv_path, "a", newline="")
-      writer = csv.writer(f)
-      if os.path.getsize(csv_path) == 0:
-        writer.writerow(["timestamp", "group", "key", "value"])
-      state.clear()  # force full dump on first packet per group
-      f.flush()
-
-    # Toggled off: close file
-    if not enabled and was_enabled:
-      if f:
-        f.close()
-        f = None
-        writer = None
-
-    was_enabled = enabled
-
-    # GPS telemetry at most 1Hz — fed through the same diff logic
-    if enabled and writer is not None:
-      sm.update(0)
-      now = time.monotonic()
-      if sm.updated['gpsLocation'] and (now - last_gps_log) >= 1.0:
-        gps = sm['gpsLocation']
-        gps_data = {
-          "latitude": f"{gps.latitude:.7f}",
-          "longitude": f"{gps.longitude:.7f}",
-          "speed": f"{gps.speed:.2f}",
-          "altitude": f"{gps.altitude:.1f}",
-          "bearing": f"{gps.bearingDeg:.1f}",
-          "accuracy": f"{gps.accuracy:.1f}",
-        }
-        ts = time.time()
-        if "gps" not in state:
-          state["gps"] = {}
-        prev_gps = state["gps"]
-        gps_changed = False
-        for key, value in gps_data.items():
-          if key not in prev_gps or prev_gps[key] != value:
-            writer.writerow([f"{ts:.6f}", "gps", key, value])
-            prev_gps[key] = value
-            gps_changed = True
-        if gps_changed:
-          f.flush()
-        last_gps_log = now
-
-    # Always drain the socket (even when disabled) to avoid backpressure
-    try:
-      raw = sock.recv_string(zmq.NOBLOCK)
-    except zmq.Again:
-      time.sleep(0.01)
-      continue
-    except zmq.ZMQError:
-      time.sleep(0.01)
-      continue
-
-    if not enabled or writer is None:
-      continue
-
-    try:
-      pkt = json.loads(raw)
-    except json.JSONDecodeError:
-      continue
-
-    ts = pkt.get("ts", 0)
-    group = pkt.get("group", "")
-    data = pkt.get("data", {})
-
-    if group not in state:
-      state[group] = {}
-
-    prev = state[group]
-    changed = False
-
-    for key, value in data.items():
-      str_val = str(value)
-      if key not in prev or prev[key] != str_val:
-        writer.writerow([f"{ts:.6f}", group, key, str_val])
-        prev[key] = str_val
-        changed = True
-
-    if changed:
-      f.flush()
-
-
-if __name__ == "__main__":
-  main()

selfdrive/clearpilot/ui_dump.py

@@ -1,12 +0,0 @@
-#!/usr/bin/env python3
-"""Query the UI process for its current widget tree. Usage: python3 -m selfdrive.clearpilot.ui_dump"""
-import zmq
-ctx = zmq.Context()
-sock = ctx.socket(zmq.REQ)
-sock.setsockopt(zmq.RCVTIMEO, 2000)
-sock.connect("ipc:///tmp/clearpilot_ui_rpc")
-sock.send_string("dump")
-try:
-  print(sock.recv_string())
-except zmq.Again:
-  print("ERROR: UI not responding (timeout)")

selfdrive/controls/controlsd.py

@@ -37,8 +37,6 @@ from openpilot.system.version import get_short_branch
 from openpilot.selfdrive.frogpilot.controls.lib.frogpilot_functions import CRUISING_SPEED, PROBABILITY, MovingAverageCalculator
 
 from openpilot.selfdrive.frogpilot.controls.lib.model_manager import RADARLESS_MODELS
-from openpilot.selfdrive.clearpilot.telemetry import tlog
-from openpilot.selfdrive.clearpilot.speed_logic import SpeedState
 from openpilot.selfdrive.frogpilot.controls.lib.speed_limit_controller import SpeedLimitController
 
 SOFT_DISABLE_TIME = 3  # seconds
@@ -49,7 +47,7 @@ CAMERA_OFFSET = 0.04
 REPLAY = "REPLAY" in os.environ
 SIMULATION = "SIMULATION" in os.environ
 TESTING_CLOSET = "TESTING_CLOSET" in os.environ
-IGNORE_PROCESSES = {"loggerd", "encoderd", "statsd", "telemetryd", "dashcamd"}
+IGNORE_PROCESSES = {"loggerd", "encoderd", "statsd"}
 
 ThermalStatus = log.DeviceState.ThermalStatus
 State = log.ControlsState.OpenpilotState
@@ -81,10 +79,6 @@ class Controls:
     self.params_memory.put_bool("CPTLkasButtonAction", False)
     self.params_memory.put_int("ScreenDisplayMode", 0)
 
-    # ClearPilot speed processing
-    self.speed_state = SpeedState()
-    self.speed_state_frame = 0
-
     self.radarless_model = self.params.get("Model", encoding='utf-8') in RADARLESS_MODELS
 
     with car.CarParams.from_bytes(self.params.get("CarParams", block=True)) as msg:
@@ -113,9 +107,8 @@ class Controls:
     self.sm = messaging.SubMaster(['deviceState', 'pandaStates', 'peripheralState', 'modelV2', 'liveCalibration',
                                    'carOutput', 'driverMonitoringState', 'longitudinalPlan', 'liveLocationKalman',
                                    'managerState', 'liveParameters', 'radarState', 'liveTorqueParameters',
-                                   'testJoystick', 'frogpilotPlan', 'gpsLocation'] + self.camera_packets + self.sensor_packets,
-                                  ignore_alive=ignore+['gpsLocation'], ignore_avg_freq=ignore+['radarState', 'testJoystick', 'gpsLocation'],
-                                  ignore_valid=['testJoystick', 'gpsLocation'],
+                                   'testJoystick', 'frogpilotPlan'] + self.camera_packets + self.sensor_packets,
+                                  ignore_alive=ignore, ignore_avg_freq=ignore+['radarState', 'testJoystick'], ignore_valid=['testJoystick', ],
                                   frequency=int(1/DT_CTRL))
 
     self.joystick_mode = self.params.get_bool("JoystickDebugMode")
@@ -204,8 +197,6 @@ class Controls:
     self.always_on_lateral_main = self.always_on_lateral and self.params.get_bool("AlwaysOnLateralMain")
 
     self.drive_added = False
-    self.driving_gear = False
-    self.was_driving_gear = False
     self.fcw_random_event_triggered = False
     self.holiday_theme_alerted = False
     self.onroad_distance_pressed = False
@@ -450,13 +441,6 @@ class Controls:
     # All events here should at least have NO_ENTRY and SOFT_DISABLE.
     num_events = len(self.events)
 
-    # CLEARPILOT: compute model standby suppression early — used by multiple checks below
-    try:
-      standby_ts = float(self.params_memory.get("ModelStandbyTs") or "0")
-    except (ValueError, TypeError):
-      standby_ts = 0
-    model_suppress = (time.monotonic() - standby_ts) < 2.0
-
     not_running = {p.name for p in self.sm['managerState'].processes if not p.running and p.shouldBeRunning}
     if self.sm.recv_frame['managerState'] and (not_running - IGNORE_PROCESSES):
       self.events.add(EventName.processNotRunning)
@@ -470,11 +454,9 @@ class Controls:
         elif not self.sm.all_freq_ok(self.camera_packets):
           self.events.add(EventName.cameraFrameRate)
     if not REPLAY and self.rk.lagging:
-      import sys
-      print(f"CLP controlsdLagging: remaining={self.rk.remaining:.4f} standstill={CS.standstill} vEgo={CS.vEgo:.2f}", file=sys.stderr)
       self.events.add(EventName.controlsdLagging)
     if not self.radarless_model:
-      if not model_suppress and (len(self.sm['radarState'].radarErrors) or (not self.rk.lagging and not self.sm.all_checks(['radarState']))):
+      if len(self.sm['radarState'].radarErrors) or (not self.rk.lagging and not self.sm.all_checks(['radarState'])):
         self.events.add(EventName.radarFault)
     if not self.sm.valid['pandaStates']:
       self.events.add(EventName.usbError)
@@ -486,7 +468,7 @@ class Controls:
     # generic catch-all. ideally, a more specific event should be added above instead
     has_disable_events = self.events.contains(ET.NO_ENTRY) and (self.events.contains(ET.SOFT_DISABLE) or self.events.contains(ET.IMMEDIATE_DISABLE))
     no_system_errors = (not has_disable_events) or (len(self.events) == num_events)
-    if (not self.sm.all_checks() or self.card.can_rcv_timeout) and no_system_errors and not model_suppress:
+    if (not self.sm.all_checks() or self.card.can_rcv_timeout) and no_system_errors:
       if not self.sm.all_alive():
         self.events.add(EventName.commIssue)
       elif not self.sm.all_freq_ok():
@@ -507,13 +489,13 @@ class Controls:
       self.logged_comm_issue = None
 
     if not (self.CP.notCar and self.joystick_mode):
-      if not self.sm['liveLocationKalman'].posenetOK and not model_suppress:
+      if not self.sm['liveLocationKalman'].posenetOK:
         self.events.add(EventName.posenetInvalid)
       if not self.sm['liveLocationKalman'].deviceStable:
         self.events.add(EventName.deviceFalling)
-      if not self.sm['liveLocationKalman'].inputsOK and not model_suppress:
+      if not self.sm['liveLocationKalman'].inputsOK:
         self.events.add(EventName.locationdTemporaryError)
-      if not self.sm['liveParameters'].valid and not TESTING_CLOSET and (not SIMULATION or REPLAY) and not model_suppress:
+      if not self.sm['liveParameters'].valid and not TESTING_CLOSET and (not SIMULATION or REPLAY):
         self.events.add(EventName.paramsdTemporaryError)
 
     # conservative HW alert. if the data or frequency are off, locationd will throw an error
@@ -559,7 +541,7 @@ class Controls:
         self.distance_traveled = 0
       self.distance_traveled += CS.vEgo * DT_CTRL
 
-      if self.sm['modelV2'].frameDropPerc > 20 and not model_suppress:
+      if self.sm['modelV2'].frameDropPerc > 20:
         self.events.add(EventName.modeldLagging)
 
 
@@ -646,14 +628,6 @@ class Controls:
     # Check if openpilot is engaged and actuators are enabled
     self.enabled = self.state in ENABLED_STATES
     self.active = self.state in ACTIVE_STATES
-
-    # CLEARPILOT: engagement telemetry disabled — was running at 100Hz, causing CPU load
-    # tlog("engage", {
-    #   "state": self.state.name if hasattr(self.state, 'name') else str(self.state),
-    #   "enabled": self.enabled, "active": self.active,
-    #   "cruise_enabled": CS.cruiseState.enabled, "cruise_available": CS.cruiseState.available,
-    #   "brakePressed": CS.brakePressed,
-    # })
     if self.active:
       self.current_alert_types.append(ET.WARNING)
 
@@ -1259,45 +1233,32 @@ class Controls:
     self.frogpilot_variables.use_ev_tables = self.params.get_bool("EVTable")
 
   def update_clearpilot_events(self, CS):
-    if (len(CS.buttonEvents) > 0):
+    if (len(CS.buttonEvents) > 0): 
       print (CS.buttonEvents)
-    if any(be.pressed and be.type == FrogPilotButtonType.lkas for be in CS.buttonEvents):
-      self.events.add(EventName.clpDebug)
+
+    # Uncomment to alert when lkas button pressed
+    # if any(be.pressed and be.type == FrogPilotButtonType.lkas for be in CS.buttonEvents):
+      # self.events.add(EventName.clpDebug)
 
   def clearpilot_state_control(self, CC, CS):
-    # CLEARPILOT: auto-reset display when shifting into drive from screen-off
-    if self.driving_gear and not self.was_driving_gear:
-      if self.params_memory.get_int("ScreenDisplayMode") == 3:
-        self.params_memory.put_int("ScreenDisplayMode", 0)
-    self.was_driving_gear = self.driving_gear
-
     if any(be.pressed and be.type == FrogPilotButtonType.lkas for be in CS.buttonEvents):
-      current = self.params_memory.get_int("ScreenDisplayMode")
-
-      if self.driving_gear:
-        # Onroad: 0→4, 1→2, 2→3, 3→4, 4→2 (never back to auto via button)
-        transitions = {0: 4, 1: 2, 2: 3, 3: 4, 4: 2}
-        new_mode = transitions.get(current, 0)
-      else:
-        # Not in drive: any except 3 → 3, state 3 → 0
-        new_mode = 0 if current == 3 else 3
-
-      self.params_memory.put_int("ScreenDisplayMode", new_mode)
-
-    # ClearPilot speed processing (~2 Hz at 100 Hz loop)
-    self.speed_state_frame += 1
-    if self.speed_state_frame % 50 == 0:
-      gps = self.sm['gpsLocation']
-      has_gps = self.sm.valid['gpsLocation'] and gps.hasFix
-      speed_ms = gps.speed if has_gps else 0.0
-      speed_limit_ms = self.params_memory.get_float("CarSpeedLimit")
-      is_metric = (self.params_memory.get("CarIsMetric", encoding="utf-8") or "0") == "1"
-      cruise_speed_ms = CS.cruiseState.speed
-      cruise_active = CS.cruiseState.enabled
-      cruise_standstill = CS.cruiseState.standstill
-      self.speed_state.update(speed_ms, has_gps, speed_limit_ms, is_metric,
-                              cruise_speed_ms, cruise_active, cruise_standstill)
+      
+      # Uncomment for debug testing.
+      # if self.params_memory.get_bool("CPTLkasButtonAction"):
+      #   self.params_memory.put_bool("CPTLkasButtonAction", False)
+      # else:
+      #   self.params_memory.put_bool("CPTLkasButtonAction", True)
+  
+      # Rotate display mode.  These are mostly used in the frontend ui app.
+      max_display_mode = 2
+      current_display_mode = self.params_memory.get_int("ScreenDisplayMode")
+      current_display_mode = current_display_mode + 1
+      if current_display_mode > max_display_mode:
+        current_display_mode = 0
+      self.params_memory.put_int("ScreenDisplayMode", current_display_mode)
 
+      # Leftovers
+      # self.params_memory.put_int("SpeedLimitLatDesired", CC.actuators.speed * CV.MS_TO_MPH )
     return CC
 
 def main():

selfdrive/controls/lib/events.py

@@ -778,8 +778,8 @@ EVENTS: dict[int, dict[str, Alert | AlertCallbackType]] = {
     ET.SOFT_DISABLE: soft_disable_alert("Sensor Data Invalid"),
   },
 
-  # CLEARPILOT: alert suppressed — event still fires for screen toggle and future actions
   EventName.clpDebug: {
+    ET.PERMANENT: clp_debug_notice,
   },
 
   EventName.noGps: {

selfdrive/frogpilot/screenrecorder/omx_encoder.cc

@@ -565,60 +565,6 @@ int OmxEncoder::encode_frame_rgba(const uint8_t *ptr, int in_width, int in_heigh
   return ret;
 }
 
-// CLEARPILOT: encode raw NV12 frames directly (no RGBA conversion needed)
-int OmxEncoder::encode_frame_nv12(const uint8_t *y_ptr, int y_stride, const uint8_t *uv_ptr, int uv_stride,
-                                   int in_width, int in_height, uint64_t ts) {
-  if (!this->is_open) {
-    return -1;
-  }
-
-  OMX_BUFFERHEADERTYPE* in_buf = nullptr;
-  while (!this->free_in.try_pop(in_buf, 20)) {
-    if (do_exit) {
-      return -1;
-    }
-  }
-
-  int ret = this->counter;
-
-  uint8_t *in_buf_ptr = in_buf->pBuffer;
-  int venus_y_stride = VENUS_Y_STRIDE(COLOR_FMT_NV12, this->width);
-  int venus_uv_stride = VENUS_UV_STRIDE(COLOR_FMT_NV12, this->width);
-  uint8_t *dst_y = in_buf_ptr;
-  uint8_t *dst_uv = in_buf_ptr + (venus_y_stride * VENUS_Y_SCANLINES(COLOR_FMT_NV12, this->height));
-
-  // Copy Y plane row by row (source stride may differ from VENUS stride)
-  for (int row = 0; row < in_height; row++) {
-    memcpy(dst_y + row * venus_y_stride, y_ptr + row * y_stride, in_width);
-  }
-  // Copy UV plane row by row
-  int uv_height = in_height / 2;
-  for (int row = 0; row < uv_height; row++) {
-    memcpy(dst_uv + row * venus_uv_stride, uv_ptr + row * uv_stride, in_width);
-  }
-
-  in_buf->nFilledLen = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, this->width, this->height);
-  in_buf->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
-  in_buf->nOffset = 0;
-  in_buf->nTimeStamp = ts / 1000LL;
-  this->last_t = in_buf->nTimeStamp;
-
-  OMX_CHECK(OMX_EmptyThisBuffer(this->handle, in_buf));
-
-  while (true) {
-    OMX_BUFFERHEADERTYPE *out_buf;
-    if (!this->done_out.try_pop(out_buf)) {
-      break;
-    }
-    handle_out_buf(this, out_buf);
-  }
-
-  this->dirty = true;
-  this->counter++;
-
-  return ret;
-}
-
 void OmxEncoder::encoder_open(const char* filename) {
   int err;
 

selfdrive/frogpilot/screenrecorder/omx_encoder.h

@@ -19,8 +19,6 @@ public:
   ~OmxEncoder();
 
   int encode_frame_rgba(const uint8_t *ptr, int in_width, int in_height, uint64_t ts);
-  int encode_frame_nv12(const uint8_t *y_ptr, int y_stride, const uint8_t *uv_ptr, int uv_stride,
-                        int in_width, int in_height, uint64_t ts);
   void encoder_open(const char* filename);
   void encoder_close();
 

selfdrive/frogpilot/screenrecorder/screenrecorder.cc

@@ -132,20 +132,13 @@ void ScreenRecorder::stop() {
 }
 
 void ScreenRecorder::update_screen() {
-  bool car_on = uiState()->scene.started || uiState()->scene.screen_recorder_debug;
-
-  if (!car_on) {
+  if (!uiState()->scene.started) {
     if (recording) {
       stop();
     }
     return;
   }
-
-  // CLEARPILOT: auto-start recording when car is on (or debug flag set)
-  if (!recording) {
-    start();
-    return;
-  }
+  if (!recording) return;
 
   if (milliseconds() - started > 1000 * 60 * 3) {
     stop();

selfdrive/manager/build.py

@@ -56,12 +56,19 @@ def build(spinner: Spinner, dirty: bool = False, minimal: bool = False) -> None:
     if scons.returncode == 0:
       Path('/data/openpilot/prebuilt').touch()
 
-      # CLEARPILOT: update prebuilt spinner if the new build is newer
+      # CLEARPILOT: update prebuilt spinner if the new build is newer.
+      # Write to a temp path then os.replace so we can swap a binary that's
+      # currently executing (the in-process spinner holds the old one open).
       new_spinner = Path(BASEDIR) / "selfdrive/ui/_spinner"
       old_spinner = Path(BASEDIR) / "selfdrive/ui/qt/spinner"
       if new_spinner.exists() and (not old_spinner.exists() or new_spinner.stat().st_mtime > old_spinner.stat().st_mtime):
         import shutil
-        shutil.copy2(str(new_spinner), str(old_spinner))
+        try:
+          tmp_spinner = old_spinner.with_name(old_spinner.name + ".new")
+          shutil.copy2(str(new_spinner), str(tmp_spinner))
+          os.replace(str(tmp_spinner), str(old_spinner))
+        except OSError as e:
+          print(f"CLP failed to update prebuilt spinner: {e}", file=sys.stderr)
 
       break
 
@@ -78,13 +85,23 @@ def build(spinner: Spinner, dirty: bool = False, minimal: bool = False) -> None:
     # Show TextWindow
     spinner.close()
     if not os.getenv("CI"):
-      # CLEARPILOT: BUILD_ONLY mode shows error on screen but doesn't block
-      t = TextWindow("openpilot failed to build\n \n" + error_s)
+      msg = "openpilot failed to build\n \n" + error_s
       if os.getenv("BUILD_ONLY"):
+        # CLEARPILOT: BUILD_ONLY mode — spawn the text window fully detached
+        # (own session, /dev/null stdio) so it stays on screen after this
+        # script exits and doesn't hold our stdout/stderr pipes open.
         print(error_s, file=sys.stderr)
+        devnull = open(os.devnull, 'r+b')
+        subprocess.Popen(
+          ["./text", msg],
+          cwd=os.path.join(BASEDIR, "selfdrive", "ui"),
+          stdin=devnull, stdout=devnull, stderr=devnull,
+          start_new_session=True,
+          close_fds=True,
+        )
       else:
-        t.wait_for_exit()
-        t.close()
+        with TextWindow(msg) as t:
+          t.wait_for_exit()
     exit(1)
 
   # enforce max cache size

selfdrive/manager/manager.py

@@ -16,7 +16,7 @@ from openpilot.common.text_window import TextWindow
 from openpilot.common.time import system_time_valid
 from openpilot.system.hardware import HARDWARE, PC
 from openpilot.selfdrive.manager.helpers import unblock_stdout, write_onroad_params, save_bootlog
-from openpilot.selfdrive.manager.process import ensure_running, init_log_dir, update_log_dir_timestamp, session_log
+from openpilot.selfdrive.manager.process import ensure_running
 from openpilot.selfdrive.manager.process_config import managed_processes
 from openpilot.selfdrive.athena.registration import register, UNREGISTERED_DONGLE_ID
 from openpilot.common.swaglog import cloudlog, add_file_handler
@@ -51,53 +51,16 @@ def frogpilot_boot_functions(frogpilot_functions):
   except Exception as e:
     print(f"An unexpected error occurred: {e}")
 
-def cleanup_old_logs(max_age_days=30):
-  """CLEARPILOT: delete session log directories older than max_age_days."""
-  import shutil
-  log_base = "/data/log2"
-  if not os.path.exists(log_base):
-    return
-  cutoff = time.time() - (max_age_days * 86400)
-  for entry in os.listdir(log_base):
-    if entry == "current":
-      continue
-    path = os.path.join(log_base, entry)
-    if os.path.isdir(path):
-      if os.path.getmtime(path) < cutoff:
-        try:
-          shutil.rmtree(path)
-        except OSError:
-          pass
-
-
 def manager_init(frogpilot_functions) -> None:
-  init_log_dir()
-  cleanup_old_logs()
-
   frogpilot_boot = threading.Thread(target=frogpilot_boot_functions, args=(frogpilot_functions,))
   frogpilot_boot.start()
 
-  save_bootlog()
+  # CLEARPILOT: skip writing boot logs to /data/media/0/realdata/boot/
+  # save_bootlog()
 
   params = Params()
   params_storage = Params("/persist/params")
   params.clear_all(ParamKeyType.CLEAR_ON_MANAGER_START)
-
-  # CLEARPILOT: always start with telemetry disabled, VPN enabled (memory params)
-  params_memory = Params("/dev/shm/params")
-  params_memory.put("TelemetryEnabled", "0")
-  params_memory.put("VpnEnabled", "1")
-  params_memory.put("ModelStandby", "0")
-  params_memory.put("ModelStandbyTs", "0")
-  params_memory.put("CarIsMetric", "0")
-  params_memory.put("ClearpilotSpeedDisplay", "")
-  params_memory.put("ClearpilotSpeedLimitDisplay", "0")
-  params_memory.put("ClearpilotHasSpeed", "0")
-  params_memory.put("ClearpilotIsMetric", "0")
-  params_memory.put("ClearpilotSpeedUnit", "mph")
-  params_memory.put("ClearpilotCruiseWarning", "")
-  params_memory.put("ClearpilotCruiseWarningSpeed", "")
-  params_memory.put("ClearpilotPlayDing", "0")
   params.clear_all(ParamKeyType.CLEAR_ON_ONROAD_TRANSITION)
   params.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
   if is_release_branch():
@@ -173,8 +136,6 @@ def manager_init(frogpilot_functions) -> None:
     ("DisableOpenpilotLongitudinal", "0"),
     ("DisableVTSCSmoothing", "0"),
     ("DisengageVolume", "100"),
-    ("DashcamDebug", "1"),
-    ("TelemetryEnabled", "0"),
     ("DragonPilotTune", "0"),
     ("DriverCamera", "0"),
     ("DynamicPathWidth", "0"),
@@ -269,7 +230,6 @@ def manager_init(frogpilot_functions) -> None:
     ("ScreenBrightnessOnroad", "101"),
     ("ScreenManagement", "1"),
     ("ScreenRecorder", "1"),
-    ("ScreenRecorderDebug", "1"),
     ("ScreenTimeout", "30"),
     ("ScreenTimeoutOnroad", "30"),
     ("SearchInput", "0"),
@@ -406,7 +366,6 @@ def manager_thread(frogpilot_functions) -> None:
   cloudlog.bind(daemon="manager")
   cloudlog.info("manager start")
   cloudlog.info({"environ": os.environ})
-  session_log.info("manager starting")
 
   params = Params()
   params_memory = Params("/dev/shm/params")
@@ -416,14 +375,6 @@ def manager_thread(frogpilot_functions) -> None:
     ignore += ["manage_athenad", "uploader"]
   if os.getenv("NOBOARD") is not None:
     ignore.append("pandad")
-  # CLEARPILOT: bench mode — disable real car processes, enable bench simulator
-  if os.getenv("BENCH_MODE") is not None:
-    ignore += ["pandad", "controlsd", "radard", "plannerd",
-               "calibrationd", "torqued", "paramsd", "locationd", "sensord",
-               "ubloxd", "pigeond", "dmonitoringmodeld", "dmonitoringd",
-               "modeld", "soundd", "loggerd", "micd",
-               "dashcamd"]
-    session_log.info("bench mode enabled")
   ignore += [x for x in os.getenv("BLOCK", "").split(",") if len(x) > 0]
 
   sm = messaging.SubMaster(['deviceState', 'carParams'], poll='deviceState')
@@ -445,7 +396,6 @@ def manager_thread(frogpilot_functions) -> None:
 
     if started and not started_prev:
       params.clear_all(ParamKeyType.CLEAR_ON_ONROAD_TRANSITION)
-      session_log.info("onroad transition")
 
       if openpilot_crashed:
         os.remove(os.path.join(sentry.CRASHES_DIR, 'error.txt'))
@@ -453,7 +403,6 @@ def manager_thread(frogpilot_functions) -> None:
     elif not started and started_prev:
       params.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
       params_memory.clear_all(ParamKeyType.CLEAR_ON_OFFROAD_TRANSITION)
-      session_log.info("offroad transition")
 
     # update onroad params, which drives boardd's safety setter thread
     if started != started_prev:
@@ -463,9 +412,6 @@ def manager_thread(frogpilot_functions) -> None:
 
     ensure_running(managed_processes.values(), started, params=params, CP=sm['carParams'], not_run=ignore)
 
-    # CLEARPILOT: rename log directory once system time is valid
-    update_log_dir_timestamp()
-
     running = ' '.join("{}{}\u001b[0m".format("\u001b[32m" if p.proc.is_alive() else "\u001b[31m", p.name)
                        for p in managed_processes.values() if p.proc)
     print(running)
@@ -483,7 +429,6 @@ def manager_thread(frogpilot_functions) -> None:
         shutdown = True
         params.put("LastManagerExitReason", f"{param} {datetime.datetime.now()}")
         cloudlog.warning(f"Shutting down manager - {param} set")
-        session_log.info("manager shutting down: %s", param)
 
     if shutdown:
       break
@@ -535,7 +480,6 @@ if __name__ == "__main__":
   except Exception:
     add_file_handler(cloudlog)
     cloudlog.exception("Manager failed to start")
-    session_log.critical("manager failed to start: %s", traceback.format_exc())
 
     try:
       managed_processes['ui'].stop()

selfdrive/manager/process.py

@@ -2,7 +2,6 @@ import importlib
 import os
 import signal
 import struct
-import sys
 import datetime
 import time
 import subprocess
@@ -18,117 +17,17 @@ import openpilot.selfdrive.sentry as sentry
 from openpilot.common.basedir import BASEDIR
 from openpilot.common.params import Params
 from openpilot.common.swaglog import cloudlog
-from openpilot.common.time import system_time_valid
 
 WATCHDOG_FN = "/dev/shm/wd_"
 ENABLE_WATCHDOG = os.getenv("NO_WATCHDOG") is None
 
-# CLEARPILOT: logging directory and session log
-# init_log_dir() must be called once from manager_init() before any process starts.
-# Until then, _log_dir and session_log are usable but write to a NullHandler.
-import logging
-
-_log_dir = "/data/log2/current"
-_time_resolved = False
-_session_handler = None
-
-session_log = logging.getLogger("clearpilot.session")
-session_log.setLevel(logging.DEBUG)
-session_log.addHandler(logging.NullHandler())
-
-
-def init_log_dir():
-  """Create /data/log2/current as a real directory for this session.
-  Called once from manager_init(). Previous current (if a real dir) is
-  renamed to a timestamp or boot-monotonic name before we create a fresh one."""
-  global _log_dir, _time_resolved, _session_handler
-
-  log_base = "/data/log2"
-  current = os.path.join(log_base, "current")
-  os.makedirs(log_base, exist_ok=True)
-
-  # If 'current' is a symlink, just remove the symlink
-  if os.path.islink(current):
-    os.unlink(current)
-  # If 'current' is a real directory (leftover from previous session that
-  # never got time-resolved), rename it out of the way
-  elif os.path.isdir(current):
-    # Use mtime of session.log (or the dir itself) for the rename
-    session_file = os.path.join(current, "session.log")
-    mtime = os.path.getmtime(session_file) if os.path.exists(session_file) else os.path.getmtime(current)
-    ts = datetime.datetime.fromtimestamp(mtime).strftime('%Y-%m-%d-%H-%M-%S')
-    dest = os.path.join(log_base, ts)
-    # Avoid collision
-    if os.path.exists(dest):
-      dest = dest + f"-{int(time.monotonic())}"
-    try:
-      os.rename(current, dest)
-    except OSError:
-      pass
-
-  os.makedirs(current, exist_ok=True)
-  _log_dir = current
-  _time_resolved = False
-
-  # Set up session log file handler
-  _session_handler = logging.FileHandler(os.path.join(_log_dir, "session.log"))
-  _session_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
-  # Remove NullHandler and add file handler
-  session_log.handlers.clear()
-  session_log.addHandler(_session_handler)
-
-  session_log.info("session started, log dir: %s", _log_dir)
-
-
-def update_log_dir_timestamp():
-  """Rename /data/log2/current to a real timestamp and replace with a symlink
-  once system time is valid."""
-  global _log_dir, _time_resolved, _session_handler
-  if _time_resolved:
-    return
-  if not system_time_valid():
-    return
-
-  log_base = "/data/log2"
-  current = os.path.join(log_base, "current")
-  ts_name = datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
-  new_dir = os.path.join(log_base, ts_name)
-
-  try:
-    os.rename(current, new_dir)
-    # Create symlink: current -> YYYY-MM-DD-HH-MM-SS
-    os.symlink(ts_name, current)
-    _log_dir = new_dir
-    _time_resolved = True
-    # Re-point session log handler (open files follow the inode, but
-    # new opens should go through the symlink — update handler for clarity)
-    session_log.removeHandler(_session_handler)
-    _session_handler.close()
-    _session_handler = logging.FileHandler(os.path.join(_log_dir, "session.log"))
-    _session_handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
-    session_log.addHandler(_session_handler)
-    session_log.info("log directory renamed to %s", _log_dir)
-
-    # Signal via param that the directory has been time-resolved
-    try:
-      from openpilot.common.params import Params
-      Params().put("LogDirInitialized", "1")
-    except Exception:
-      pass
-  except OSError:
-    pass
+timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+_log_dir = f"/data/log2/{timestamp}"
+os.makedirs(_log_dir, exist_ok=True)
 
 
 
-def launcher(proc: str, name: str, log_path: str) -> None:
-  # CLEARPILOT: redirect stderr to per-process log file
-  try:
-    log_file = open(log_path, 'a')
-    os.dup2(log_file.fileno(), sys.stderr.fileno())
-    os.dup2(log_file.fileno(), sys.stdout.fileno())
-  except Exception as e:
-    print(f"CLEARPILOT: stderr redirect failed for {name}: {e}", file=sys.stderr)
-
+def launcher(proc: str, name: str) -> None:
   try:
     # import the process
     mod = importlib.import_module(proc)
@@ -154,17 +53,9 @@ def launcher(proc: str, name: str, log_path: str) -> None:
     raise
 
 
-def nativelauncher(pargs: list[str], cwd: str, name: str, log_path: str) -> None:
+def nativelauncher(pargs: list[str], cwd: str, name: str) -> None:
   os.environ['MANAGER_DAEMON'] = name
 
-  # CLEARPILOT: redirect stderr and stdout to per-process log file
-  try:
-    log_file = open(log_path, 'a')
-    os.dup2(log_file.fileno(), sys.stderr.fileno())
-    os.dup2(log_file.fileno(), sys.stdout.fileno())
-  except Exception as e:
-    print(f"CLEARPILOT: stderr redirect failed for {name}: {e}", file=sys.stderr)
-
   # exec the process
   os.chdir(cwd)
   os.execvp(pargs[0], pargs)
@@ -219,7 +110,6 @@ class ManagerProcess(ABC):
     if dt > self.watchdog_max_dt:
       if (self.watchdog_seen or self.always_watchdog and self.proc.exitcode is not None) and ENABLE_WATCHDOG:
         cloudlog.error(f"Watchdog timeout for {self.name} (exitcode {self.proc.exitcode}) restarting ({started=})")
-        session_log.warning("watchdog timeout for %s (exitcode %s), restarting", self.name, self.proc.exitcode)
         self.restart()
     else:
       self.watchdog_seen = True
@@ -249,10 +139,6 @@ class ManagerProcess(ABC):
 
     ret = self.proc.exitcode
     cloudlog.info(f"{self.name} is dead with {ret}")
-    if ret is not None and ret != 0:
-      session_log.error("process %s died with exit code %s", self.name, ret)
-    elif ret == 0:
-      session_log.info("process %s stopped (exit 0)", self.name)
 
     if self.proc.exitcode is not None:
       self.shutting_down = False
@@ -312,13 +198,9 @@ class NativeProcess(ManagerProcess):
     global _log_dir
     log_path = _log_dir+"/"+self.name+".log"
 
-    # CLEARPILOT: ensure log file exists even if child redirect fails
-    open(log_path, 'a').close()
-
     cwd = os.path.join(BASEDIR, self.cwd)
     cloudlog.info(f"starting process {self.name}")
-    session_log.info("starting %s", self.name)
-    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name, log_path))
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.cmdline, cwd, self.name))
     self.proc.start()
     self.watchdog_seen = False
     self.shutting_down = False
@@ -349,12 +231,8 @@ class PythonProcess(ManagerProcess):
 
     global _log_dir
     log_path = _log_dir+"/"+self.name+".log"
-    # CLEARPILOT: ensure log file exists even if child redirect fails
-    open(log_path, 'a').close()
-
     cloudlog.info(f"starting python {self.module}")
-    session_log.info("starting %s", self.name)
-    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name, log_path))
+    self.proc = Process(name=self.name, target=self.launcher, args=(self.module, self.name))
     self.proc.start()
     self.watchdog_seen = False
     self.shutting_down = False
@@ -398,7 +276,6 @@ class DaemonProcess(ManagerProcess):
         pass
 
     cloudlog.info(f"starting daemon {self.name}")
-    session_log.info("starting daemon %s", self.name)
     proc = subprocess.Popen(['python', '-m', self.module],
                                stdin=open('/dev/null'),
                                stdout=open(log_path, 'a'),

selfdrive/manager/process_config.py

@@ -7,7 +7,6 @@ from openpilot.selfdrive.manager.process import PythonProcess, NativeProcess, Da
 
 
 WEBCAM = os.getenv("USE_WEBCAM") is not None
-BENCH_MODE = os.getenv("BENCH_MODE") is not None
 
 def driverview(started: bool, params: Params, CP: car.CarParams) -> bool:
   return started or params.get_bool("IsDriverViewEnabled")
@@ -52,14 +51,10 @@ def allow_uploads(started, params, CP: car.CarParams) -> bool:
   allow_uploads = not (params.get_bool("DeviceManagement") and params.get_bool("NoUploads"))
   return allow_uploads
 
-# ClearPilot functions
-def dashcam_should_run(started, params, CP: car.CarParams) -> bool:
-  return True  # CLEARPILOT: dashcamd manages its own trip lifecycle
-
 procs = [
   DaemonProcess("manage_athenad", "selfdrive.athena.manage_athenad", "AthenadPid"),
 
-  NativeProcess("camerad", "system/camerad", ["./camerad"], always_run),
+  NativeProcess("camerad", "system/camerad", ["./camerad"], driverview),
   NativeProcess("logcatd", "system/logcatd", ["./logcatd"], allow_logging),
   NativeProcess("proclogd", "system/proclogd", ["./proclogd"], allow_logging),
   PythonProcess("logmessaged", "system.logmessaged", allow_logging),
@@ -67,10 +62,12 @@ procs = [
   PythonProcess("timed", "system.timed", always_run, enabled=not PC),
 
   PythonProcess("dmonitoringmodeld", "selfdrive.modeld.dmonitoringmodeld", driverview, enabled=(not PC or WEBCAM)),
-  # CLEARPILOT: disabled video encoding (camera .hevc files) — CAN/sensor logs still recorded via loggerd
+  # CLEARPILOT: disabled segment + camera logging — no rlog/qlog or .hevc
+  # files written to /data/media/0/realdata. We don't use comma's upload/
+  # replay pipeline. Keep deleter running for any leftover cleanup.
   # NativeProcess("encoderd", "system/loggerd", ["./encoderd"], allow_logging),
   # NativeProcess("stream_encoderd", "system/loggerd", ["./encoderd", "--stream"], notcar),
-  NativeProcess("loggerd", "system/loggerd", ["./loggerd"], allow_logging),
+  # NativeProcess("loggerd", "system/loggerd", ["./loggerd"], allow_logging),
   NativeProcess("modeld", "selfdrive/modeld", ["./modeld"], only_onroad),
   #NativeProcess("mapsd", "selfdrive/navd", ["./mapsd"], only_onroad),
   #PythonProcess("navmodeld", "selfdrive.modeld.navmodeld", only_onroad),
@@ -84,8 +81,7 @@ procs = [
   PythonProcess("controlsd", "selfdrive.controls.controlsd", only_onroad),
   PythonProcess("deleter", "system.loggerd.deleter", always_run),
   PythonProcess("dmonitoringd", "selfdrive.monitoring.dmonitoringd", driverview, enabled=(not PC or WEBCAM)),
-  # PythonProcess("qcomgpsd", "system.qcomgpsd.qcomgpsd", qcomgps, enabled=TICI),
-  PythonProcess("gpsd", "system.clearpilot.gpsd", qcomgps, enabled=TICI),
+  # PythonProcess("qcomgpsd", "system.qcomgpsd.qcomgpsd", qcomgps, enabled=TICI),  # Fixme
   # PythonProcess("ugpsd", "system.ugpsd", only_onroad, enabled=TICI),
   #PythonProcess("navd", "selfdrive.navd.navd", only_onroad),
   PythonProcess("pandad", "selfdrive.boardd.pandad", always_run),
@@ -108,11 +104,6 @@ procs = [
   # FrogPilot processes
   PythonProcess("fleet_manager", "selfdrive.frogpilot.fleetmanager.fleet_manager", always_run),
   PythonProcess("frogpilot_process", "selfdrive.frogpilot.frogpilot_process", always_run),
-
-  # ClearPilot processes
-  NativeProcess("dashcamd", "selfdrive/clearpilot", ["./dashcamd"], dashcam_should_run),
-  PythonProcess("telemetryd", "selfdrive.clearpilot.telemetryd", always_run),
-  PythonProcess("bench_onroad", "selfdrive.clearpilot.bench_onroad", always_run, enabled=BENCH_MODE),
 ]
 
 managed_processes = {p.name: p for p in procs}

selfdrive/modeld/modeld.py

@@ -134,15 +134,11 @@ def main(demo=False):
   setproctitle(PROCESS_NAME)
   config_realtime_process(7, 54)
 
-  import time as _time
   cloudlog.warning("setting up CL context")
-  _t0 = _time.monotonic()
   cl_context = CLContext()
-  _t1 = _time.monotonic()
-  cloudlog.warning("CL context ready in %.3fs; loading model", _t1 - _t0)
+  cloudlog.warning("CL context ready; loading model")
   model = ModelState(cl_context)
-  _t2 = _time.monotonic()
-  cloudlog.warning("model loaded in %.3fs (total init %.3fs), modeld starting", _t2 - _t1, _t2 - _t0)
+  cloudlog.warning("models loaded, modeld starting")
 
   # visionipc clients
   while True:
@@ -183,9 +179,6 @@ def main(demo=False):
   model_transform_main = np.zeros((3, 3), dtype=np.float32)
   model_transform_extra = np.zeros((3, 3), dtype=np.float32)
   live_calib_seen = False
-  model_standby = False
-  last_standby_ts_write = 0
-  params_memory = Params("/dev/shm/params")
   nav_features = np.zeros(ModelConstants.NAV_FEATURE_LEN, dtype=np.float32)
   nav_instructions = np.zeros(ModelConstants.NAV_INSTRUCTION_LEN, dtype=np.float32)
   buf_main, buf_extra = None, None
@@ -240,50 +233,6 @@ def main(demo=False):
       meta_extra = meta_main
 
     sm.update(0)
-
-    # CLEARPILOT: power saving — three modes based on driving state
-    #   Full 20fps: lat active or lane changing
-    #   Reduced 4fps: not lat active, not standstill (driving without cruise)
-    #   Standby 0fps: standstill
-    lat_active = sm['carControl'].latActive
-    lane_changing = params_memory.get_bool("no_lat_lane_change")
-    standstill = sm['carState'].standstill
-    calibrating = sm['liveCalibration'].calStatus != log.LiveCalibrationData.Status.calibrated
-    full_rate = lat_active or lane_changing or calibrating
-
-    # Standby transitions (standstill only)
-    should_standby = standstill and not full_rate
-    if should_standby and not model_standby:
-      params_memory.put_bool("ModelStandby", True)
-      model_standby = True
-      cloudlog.warning("modeld: standby ON (standstill)")
-    elif not should_standby and model_standby:
-      params_memory.put_bool("ModelStandby", False)
-      model_standby = False
-      run_count = 0
-      frame_dropped_filter.x = 0.
-      cloudlog.warning("modeld: standby OFF")
-    if model_standby:
-      now = _time.monotonic()
-      if now - last_standby_ts_write > 1.0:
-        params_memory.put("ModelStandbyTs", str(now))
-        last_standby_ts_write = now
-      last_vipc_frame_id = meta_main.frame_id
-      continue
-
-    # Reduced framerate: 4fps when not lat active and not standstill
-    # Skip 4 out of every 5 frames (20fps -> 4fps)
-    # Write standby timestamp so controlsd suppresses transient errors
-    if not full_rate:
-      now = _time.monotonic()
-      if now - last_standby_ts_write > 1.0:
-        params_memory.put("ModelStandbyTs", str(now))
-        last_standby_ts_write = now
-      if run_count % 5 != 0:
-        last_vipc_frame_id = meta_main.frame_id
-        run_count += 1
-        continue
-
     desire = DH.desire
     is_rhd = sm["driverMonitoringState"].isRHD
     frame_id = sm["roadCameraState"].frameId

selfdrive/thermald/fan_controller.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-import os
 from abc import ABC, abstractmethod
 
 from openpilot.common.realtime import DT_TRML
@@ -7,11 +6,9 @@ from openpilot.common.numpy_fast import interp
 from openpilot.common.swaglog import cloudlog
 from openpilot.selfdrive.controls.lib.pid import PIDController
 
-BENCH_MODE = os.environ.get("BENCH_MODE") == "1"
-
 class BaseFanController(ABC):
   @abstractmethod
-  def update(self, cur_temp: float, ignition: bool, standstill: bool = False) -> int:
+  def update(self, cur_temp: float, ignition: bool) -> int:
     pass
 
 
@@ -23,25 +20,9 @@ class TiciFanController(BaseFanController):
     self.last_ignition = False
     self.controller = PIDController(k_p=0, k_i=4e-3, k_f=1, rate=(1 / DT_TRML))
 
-  def update(self, cur_temp: float, ignition: bool, standstill: bool = False) -> int:
-    # CLEARPILOT: bench mode always uses normal onroad fan range (30-100%)
-    if BENCH_MODE and ignition:
-      self.controller.neg_limit = -100
-      self.controller.pos_limit = -30
-    # CLEARPILOT: at standstill below 74°C, clamp to 0-30% (quiet)
-    # at standstill above 74°C, allow full 0-100% range
-    elif ignition and standstill and cur_temp < 74:
-      self.controller.neg_limit = -30
-      self.controller.pos_limit = 0
-    elif ignition and standstill:
-      self.controller.neg_limit = -100
-      self.controller.pos_limit = 0
-    elif ignition:
-      self.controller.neg_limit = -100
-      self.controller.pos_limit = -15
-    else:
-      self.controller.neg_limit = -30
-      self.controller.pos_limit = 0
+  def update(self, cur_temp: float, ignition: bool) -> int:
+    self.controller.neg_limit = -(100 if ignition else 30)
+    self.controller.pos_limit = -(30 if ignition else 0)
 
     if ignition != self.last_ignition:
       self.controller.reset()

selfdrive/thermald/thermald.py

@@ -164,7 +164,7 @@ def hw_state_thread(end_event, hw_queue):
 
 def thermald_thread(end_event, hw_queue) -> None:
   pm = messaging.PubMaster(['deviceState', 'frogpilotDeviceState'])
-  sm = messaging.SubMaster(["peripheralState", "gpsLocationExternal", "controlsState", "pandaStates", "carState"], poll="pandaStates")
+  sm = messaging.SubMaster(["peripheralState", "gpsLocationExternal", "controlsState", "pandaStates"], poll="pandaStates")
 
   count = 0
 
@@ -290,8 +290,7 @@ def thermald_thread(end_event, hw_queue) -> None:
     msg.deviceState.maxTempC = all_comp_temp
 
     if fan_controller is not None:
-      standstill = sm['carState'].standstill if sm.seen['carState'] else False
-      msg.deviceState.fanSpeedPercentDesired = fan_controller.update(all_comp_temp, onroad_conditions["ignition"], standstill)
+      msg.deviceState.fanSpeedPercentDesired = fan_controller.update(all_comp_temp, onroad_conditions["ignition"])
 
     is_offroad_for_5_min = (started_ts is None) and ((not started_seen) or (off_ts is None) or (time.monotonic() - off_ts > 60 * 5))
     if is_offroad_for_5_min and offroad_comp_temp > OFFROAD_DANGER_TEMP:
@@ -412,16 +411,6 @@ def thermald_thread(end_event, hw_queue) -> None:
     # Check if we need to shut down
     if power_monitor.should_shutdown(onroad_conditions["ignition"], in_car, off_ts, started_seen):
       cloudlog.warning(f"shutting device down, offroad since {off_ts}")
-      # CLEARPILOT: signal dashcamd to close recording gracefully before power-off
-      params.put_bool("DashcamShutdown", True)
-      deadline = time.monotonic() + 15.0
-      while time.monotonic() < deadline:
-        if not params.getBool("DashcamShutdown"):
-          cloudlog.info("dashcamd shutdown ack received")
-          break
-        time.sleep(0.5)
-      else:
-        cloudlog.warning("dashcamd shutdown ack timeout, proceeding")
       params.put_bool("DoShutdown", True)
 
     msg.deviceState.started = started_ts is not None

selfdrive/ui/SConscript

@@ -39,7 +39,7 @@ qt_src = ["main.cc", "qt/sidebar.cc", "qt/onroad.cc", "qt/body.cc",
           "qt/window.cc", "qt/home.cc", "qt/offroad/settings.cc",
           "qt/offroad/software_settings.cc", "qt/offroad/onboarding.cc",
           "qt/offroad/driverview.cc", "qt/offroad/experimental_mode.cc",
-          "../frogpilot/screenrecorder/omx_encoder.cc",  # kept for dashcamd .o dependency
+          "../frogpilot/screenrecorder/omx_encoder.cc", "../frogpilot/screenrecorder/screenrecorder.cc",
           "qt/ready.cc"]
 
 # build translation files
@@ -77,7 +77,8 @@ qt_env.Program("_text", ["qt/text.cc"], LIBS=qt_libs)
 qt_env.Program("_spinner", ["qt/spinner.cc"], LIBS=qt_libs)
 
 
-# Clearpilot tools
+# Clearpilot
+# Create clearpilot tools
 qt_env.Program("/data/openpilot/system/clearpilot/tools/qt_shell", ["/data/openpilot/system/clearpilot/tools/qt_shell.cc"], LIBS=qt_libs)
 
 # build main UI

selfdrive/ui/main.cc

@@ -1,9 +1,4 @@
 #include <sys/resource.h>
-#include <csignal>
-#include <cstdio>
-#include <cstdlib>
-#include <execinfo.h>
-#include <unistd.h>
 
 #include <QApplication>
 #include <QTranslator>
@@ -13,27 +8,7 @@
 #include "selfdrive/ui/qt/util.h"
 #include "selfdrive/ui/qt/window.h"
 
-// CLEARPILOT: crash handler — prints stack trace to stderr on SIGSEGV/SIGABRT
-static void crash_handler(int sig) {
-  const char *sig_name = (sig == SIGSEGV) ? "SIGSEGV" : (sig == SIGABRT) ? "SIGABRT" : "SIGNAL";
-  fprintf(stderr, "\n=== CRASH: %s (signal %d) ===\n", sig_name, sig);
-
-  void *frames[64];
-  int count = backtrace(frames, 64);
-  fprintf(stderr, "Backtrace (%d frames):\n", count);
-  backtrace_symbols_fd(frames, count, STDERR_FILENO);
-  fprintf(stderr, "=== END CRASH ===\n");
-  fflush(stderr);
-
-  // Re-raise to get default behavior (core dump / exit)
-  signal(sig, SIG_DFL);
-  raise(sig);
-}
-
 int main(int argc, char *argv[]) {
-  signal(SIGSEGV, crash_handler);
-  signal(SIGABRT, crash_handler);
-
   setpriority(PRIO_PROCESS, 0, -20);
 
   qInstallMessageHandler(swagLogMessageHandler);

selfdrive/ui/qt/home.cc

@@ -1,20 +1,14 @@
 #include "selfdrive/ui/qt/home.h"
 
-#include <cstdlib>
 #include <QHBoxLayout>
 #include <QMouseEvent>
 #include <QStackedWidget>
 #include <QVBoxLayout>
 
-#include "common/swaglog.h"
-#include "common/params.h"
-#include "system/hardware/hw.h"
+#include "selfdrive/ui/qt/offroad/experimental_mode.h"
 #include "selfdrive/ui/qt/util.h"
-#include "selfdrive/ui/qt/widgets/controls.h"
-#include "selfdrive/ui/qt/widgets/input.h"
-#include "selfdrive/ui/qt/widgets/scrollview.h"
-#include "selfdrive/ui/qt/network/networking.h"
-#include "cereal/messaging/messaging.h"
+#include "selfdrive/ui/qt/widgets/drive_stats.h"
+#include "system/hardware/hw.h"
 
 // HomeWindow: the container for the offroad and onroad UIs
 
@@ -27,7 +21,6 @@ HomeWindow::HomeWindow(QWidget* parent) : QWidget(parent) {
   main_layout->setSpacing(0);
 
   sidebar = new Sidebar(this);
-  sidebar->setVisible(false);
   main_layout->addWidget(sidebar);
   QObject::connect(sidebar, &Sidebar::openSettings, this, &HomeWindow::openSettings);
   QObject::connect(sidebar, &Sidebar::openOnroad, this, &HomeWindow::showOnroad);
@@ -35,17 +28,8 @@ HomeWindow::HomeWindow(QWidget* parent) : QWidget(parent) {
   slayout = new QStackedLayout();
   main_layout->addLayout(slayout);
 
-  home = new ClearPilotPanel(this);
-  QObject::connect(home, &ClearPilotPanel::openSettings, this, &HomeWindow::openSettings);
-  QObject::connect(home, &ClearPilotPanel::openStatus, this, &HomeWindow::openStatus);
-  QObject::connect(home, &ClearPilotPanel::closePanel, [=]() {
-    // Return to splash or onroad depending on state
-    if (uiState()->scene.started) {
-      slayout->setCurrentWidget(onroad);
-    } else {
-      slayout->setCurrentWidget(ready);
-    }
-  });
+  home = new OffroadHome(this);
+  QObject::connect(home, &OffroadHome::openSettings, this, &HomeWindow::openSettings);
   slayout->addWidget(home);
 
   onroad = new OnroadWindow(this);
@@ -54,8 +38,7 @@ HomeWindow::HomeWindow(QWidget* parent) : QWidget(parent) {
   // CLEARPILOT
   ready = new ReadyWindow(this);
   slayout->addWidget(ready);
-  slayout->setCurrentWidget(ready);  // show splash immediately, not ClearPilotPanel
-
+  
   driver_view = new DriverViewWindow(this);
   connect(driver_view, &DriverViewWindow::done, [=] {
     showDriverView(false);
@@ -81,76 +64,52 @@ void HomeWindow::showSidebar(bool show) {
 }
 
 void HomeWindow::updateState(const UIState &s) {
+  // const SubMaster &sm = *(s.sm);
   if (s.scene.started) {
     showDriverView(s.scene.driver_camera_timer >= 10, true);
-
-    // CLEARPILOT: show splash screen when onroad but in park
-    // In nightrider mode (states 1,4), stay on onroad view in park — only offroad transition shows splash
-    bool parked = s.scene.parked;
-    int screenMode = paramsMemory.getInt("ScreenDisplayMode");
-    bool nightrider = (screenMode == 1 || screenMode == 4);
-
-    if (parked && !was_parked_onroad) {
-      if (!nightrider) {
-        LOGW("CLP UI: park transition -> showing splash");
-        slayout->setCurrentWidget(ready);
-      }
-    } else if (!parked && was_parked_onroad) {
-      LOGW("CLP UI: drive transition -> showing onroad");
-      slayout->setCurrentWidget(onroad);
-      ready->has_driven = true;
-    }
-    was_parked_onroad = parked;
-
-    // CLEARPILOT: honor display on/off while showing splash in park (normal mode only)
-    if (parked && ready->isVisible()) {
-      if (screenMode == 3) {
-        Hardware::set_display_power(false);
-      } else {
-        Hardware::set_display_power(true);
-      }
-    }
   }
 }
 
 void HomeWindow::offroadTransition(bool offroad) {
-  sidebar->setVisible(false);
   if (offroad) {
-    LOGW("CLP UI: offroad transition -> showing splash");
-    was_parked_onroad = false;
+    sidebar->setVisible(false);
     slayout->setCurrentWidget(ready);
   } else {
-    // CLEARPILOT: start onroad in splash — updateState will switch to
-    // camera view once the car shifts out of park
-    LOGW("CLP UI: onroad transition -> showing splash (parked)");
-    was_parked_onroad = true;
-    slayout->setCurrentWidget(ready);
+    sidebar->setVisible(false);
+    slayout->setCurrentWidget(onroad);
   }
 }
 
 void HomeWindow::showDriverView(bool show, bool started) {
   if (show) {
-    LOGW("CLP UI: showDriverView(true) -> driver_view");
     emit closeSettings();
     slayout->setCurrentWidget(driver_view);
-    sidebar->setVisible(false);
-  } else if (!started) {
-    // Offroad, not started — show home menu
-    slayout->setCurrentWidget(home);
-    sidebar->setVisible(false);
+    sidebar->setVisible(show == false);
+  } else {
+    if (started) {
+      slayout->setCurrentWidget(onroad);
+      sidebar->setVisible(params.getBool("Sidebar"));
+    } else {
+      slayout->setCurrentWidget(home);
+      sidebar->setVisible(show == false);
+    }
   }
-  // CLEARPILOT: when started, don't touch slayout here —
-  // updateState handles park->splash and drive->onroad transitions
 }
 
 void HomeWindow::mousePressEvent(QMouseEvent* e) {
-  // CLEARPILOT: tap from any view goes to ClearPilotPanel
-  if (ready->isVisible() || onroad->isVisible()) {
-    LOGW("CLP UI: tap -> showing ClearPilotPanel");
-    sidebar->setVisible(false);
-    home->resetToGeneral();
+  // CLEARPILOT todo - tap on main goes straight to settings
+  // Unless we click a debug widget.
+
+  // CLEARPILOT - click ready shows home
+  if (!onroad->isVisible() && ready->isVisible()) {
+    sidebar->setVisible(true);
     slayout->setCurrentWidget(home);
   }
+
+  // Todo: widgets
+  if (onroad->isVisible()) {
+    emit openSettings();
+  }
 }
 
 void HomeWindow::mouseDoubleClickEvent(QMouseEvent* e) {
@@ -158,293 +117,132 @@ void HomeWindow::mouseDoubleClickEvent(QMouseEvent* e) {
   // const SubMaster &sm = *(uiState()->sm);
 }
 
-// CLEARPILOT: ClearPilotPanel — settings-style sidebar menu
+// OffroadHome: the offroad home page
 
-static const char *clpSidebarBtnStyle = R"(
-  QPushButton {
-    color: grey;
-    border: none;
-    background: none;
-    font-size: 65px;
-    font-weight: 500;
+OffroadHome::OffroadHome(QWidget* parent) : QFrame(parent) {
+  QVBoxLayout* main_layout = new QVBoxLayout(this);
+  main_layout->setContentsMargins(40, 40, 40, 40);
+
+  // top header
+  QHBoxLayout* header_layout = new QHBoxLayout();
+  header_layout->setContentsMargins(0, 0, 0, 0);
+  header_layout->setSpacing(16);
+
+  update_notif = new QPushButton(tr("UPDATE"));
+  update_notif->setVisible(false);
+  update_notif->setStyleSheet("background-color: #364DEF;");
+  QObject::connect(update_notif, &QPushButton::clicked, [=]() { center_layout->setCurrentIndex(1); });
+  header_layout->addWidget(update_notif, 0, Qt::AlignHCenter | Qt::AlignLeft);
+
+  alert_notif = new QPushButton();
+  alert_notif->setVisible(false);
+  alert_notif->setStyleSheet("background-color: #E22C2C;");
+  QObject::connect(alert_notif, &QPushButton::clicked, [=] { center_layout->setCurrentIndex(2); });
+  header_layout->addWidget(alert_notif, 0, Qt::AlignHCenter | Qt::AlignLeft);
+
+  date = new ElidedLabel();
+  header_layout->addWidget(date, 0, Qt::AlignHCenter | Qt::AlignLeft);
+
+  version = new ElidedLabel();
+  header_layout->addWidget(version, 0, Qt::AlignHCenter | Qt::AlignRight);
+
+  main_layout->addLayout(header_layout);
+
+  // main content
+  main_layout->addSpacing(25);
+  center_layout = new QStackedLayout();
+
+  QWidget *home_widget = new QWidget(this);
+  {
+    QHBoxLayout *home_layout = new QHBoxLayout(home_widget);
+    home_layout->setContentsMargins(0, 0, 0, 0);
+    home_layout->setSpacing(30);
+    
+    // // // Create a QWebEngineView
+    // QWebEngineView *web_view = new QWebEngineView();
+    // web_view->load(QUrl("http://fark.com"));
+    
+    // // Add the QWebEngineView to the layout
+    // home_layout->addWidget(web_view);
   }
-  QPushButton:checked {
-    color: white;
-  }
-  QPushButton:pressed {
-    color: #ADADAD;
-  }
-)";
+  center_layout->addWidget(home_widget);
 
-// clpActionBtnStyle removed — no longer used
+  // add update & alerts widgets
+  update_widget = new UpdateAlert();
+  QObject::connect(update_widget, &UpdateAlert::dismiss, [=]() { center_layout->setCurrentIndex(0); });
+  center_layout->addWidget(update_widget);
+  alerts_widget = new OffroadAlert();
+  QObject::connect(alerts_widget, &OffroadAlert::dismiss, [=]() { center_layout->setCurrentIndex(0); });
+  center_layout->addWidget(alerts_widget);
 
-// Shutdown timer: param value -> display label
-static QString shutdownLabel(int val) {
-  if (val == 0) return "5 mins";
-  if (val <= 3) return QString::number(val * 15) + " mins";
-  int hours = val - 3;
-  return QString::number(hours) + (hours == 1 ? " hour" : " hours");
-}
+  main_layout->addLayout(center_layout, 1);
 
-ClearPilotPanel::ClearPilotPanel(QWidget* parent) : QFrame(parent) {
-  // Sidebar
-  QWidget *sidebar_widget = new QWidget;
-  QVBoxLayout *sidebar_layout = new QVBoxLayout(sidebar_widget);
-  sidebar_layout->setContentsMargins(50, 50, 100, 50);
-
-  // Close button
-  QPushButton *close_btn = new QPushButton("← Back");
-  close_btn->setStyleSheet(R"(
-    QPushButton {
-      color: white;
-      border-radius: 25px;
-      background: #292929;
-      font-size: 50px;
-      font-weight: 500;
-    }
-    QPushButton:pressed {
-      color: #ADADAD;
-    }
-  )");
-  close_btn->setFixedSize(300, 125);
-  sidebar_layout->addSpacing(10);
-  sidebar_layout->addWidget(close_btn, 0, Qt::AlignRight);
-  QObject::connect(close_btn, &QPushButton::clicked, [=]() { emit closePanel(); });
-
-  // Panel content area
-  panel_widget = new QStackedWidget();
-
-  // ── General panel ──
-  ListWidget *general_panel = new ListWidget(this);
-  general_panel->setContentsMargins(50, 25, 50, 25);
-
-  // Status button
-  auto *status_btn = new ButtonControl("System Status", "VIEW", "");
-  connect(status_btn, &ButtonControl::clicked, [=]() { emit openStatus(); });
-  general_panel->addItem(status_btn);
-
-  // Reset Calibration
-  auto resetCalibBtn = new ButtonControl("Reset Calibration", "RESET", "");
-  connect(resetCalibBtn, &ButtonControl::showDescriptionEvent, [=]() {
-    QString desc = "openpilot requires the device to be mounted within 4° left or right and "
-                   "within 5° up or 9° down. openpilot is continuously calibrating, resetting is rarely required.";
-    std::string calib_bytes = Params().get("CalibrationParams");
-    if (!calib_bytes.empty()) {
-      try {
-        AlignedBuffer aligned_buf;
-        capnp::FlatArrayMessageReader cmsg(aligned_buf.align(calib_bytes.data(), calib_bytes.size()));
-        auto calib = cmsg.getRoot<cereal::Event>().getLiveCalibration();
-        if (calib.getCalStatus() != cereal::LiveCalibrationData::Status::UNCALIBRATED) {
-          double pitch = calib.getRpyCalib()[1] * (180 / M_PI);
-          double yaw = calib.getRpyCalib()[2] * (180 / M_PI);
-          desc += QString(" Your device is pointed %1° %2 and %3° %4.")
-                      .arg(QString::number(std::abs(pitch), 'g', 1), pitch > 0 ? "down" : "up",
-                           QString::number(std::abs(yaw), 'g', 1), yaw > 0 ? "left" : "right");
-        }
-      } catch (...) {
-        qInfo() << "invalid CalibrationParams";
-      }
-    }
-    qobject_cast<ButtonControl *>(sender())->setDescription(desc);
-  });
-  connect(resetCalibBtn, &ButtonControl::clicked, [=]() {
-    if (ConfirmationDialog::confirm("Are you sure you want to reset calibration?", "Reset", this)) {
-      Params().remove("CalibrationParams");
-      Params().remove("LiveTorqueParameters");
-    }
-  });
-  general_panel->addItem(resetCalibBtn);
-
-  // Shutdown Timer
-  int cur_shutdown = Params().getInt("DeviceShutdown");
-  auto shutdownBtn = new ButtonControl("Shutdown Timer", shutdownLabel(cur_shutdown),
-    "How long the device stays on after the car is turned off.");
-  connect(shutdownBtn, &ButtonControl::clicked, [=]() {
-    QStringList options;
-    for (int i = 0; i <= 33; i++) {
-      options << shutdownLabel(i);
-    }
-    int current = Params().getInt("DeviceShutdown");
-    QString sel = MultiOptionDialog::getSelection("Shutdown Timer", options, shutdownLabel(current), this);
-    if (!sel.isEmpty()) {
-      int idx = options.indexOf(sel);
-      if (idx >= 0) {
-        Params().putInt("DeviceShutdown", idx);
-        shutdownBtn->setValue(shutdownLabel(idx));
-      }
-    }
-  });
-  general_panel->addItem(shutdownBtn);
-
-  // Power buttons
-  QHBoxLayout *power_layout = new QHBoxLayout();
-  power_layout->setSpacing(30);
-
-  QPushButton *reboot_btn = new QPushButton("Reboot");
-  reboot_btn->setObjectName("reboot_btn");
-  power_layout->addWidget(reboot_btn);
-
-  QPushButton *softreboot_btn = new QPushButton("Soft Reboot");
-  softreboot_btn->setObjectName("softreboot_btn");
-  power_layout->addWidget(softreboot_btn);
-
-  QPushButton *poweroff_btn = new QPushButton("Power Off");
-  poweroff_btn->setObjectName("poweroff_btn");
-  power_layout->addWidget(poweroff_btn);
-
-  QObject::connect(reboot_btn, &QPushButton::clicked, [=]() {
-    if (!uiState()->engaged()) {
-      if (ConfirmationDialog::confirm("Are you sure you want to reboot?", "Reboot", this)) {
-        if (!uiState()->engaged()) {
-          Params().putBool("DoReboot", true);
-        }
-      }
-    } else {
-      ConfirmationDialog::alert("Disengage to Reboot", this);
-    }
-  });
-
-  QObject::connect(softreboot_btn, &QPushButton::clicked, [=]() {
-    if (!uiState()->engaged()) {
-      if (ConfirmationDialog::confirm("Are you sure you want to soft reboot?", "Soft Reboot", this)) {
-        if (!uiState()->engaged()) {
-          Params().putBool("DoSoftReboot", true);
-        }
-      }
-    } else {
-      ConfirmationDialog::alert("Disengage to Soft Reboot", this);
-    }
-  });
-
-  QObject::connect(poweroff_btn, &QPushButton::clicked, [=]() {
-    if (!uiState()->engaged()) {
-      if (ConfirmationDialog::confirm("Are you sure you want to power off?", "Power Off", this)) {
-        if (!uiState()->engaged()) {
-          Params().putBool("DoShutdown", true);
-        }
-      }
-    } else {
-      ConfirmationDialog::alert("Disengage to Power Off", this);
-    }
-  });
-
-  general_panel->addItem(power_layout);
-
-  // ── Network panel ──
-  Networking *network_panel = new Networking(this);
-  // Hide APN button — find by searching QPushButton labels inside AdvancedNetworking
-  for (auto *btn : network_panel->findChildren<QPushButton *>()) {
-    if (btn->text().contains("APN", Qt::CaseInsensitive)) {
-      // Hide the parent AbstractControl frame, not just the button
-      if (auto *frame = qobject_cast<QFrame *>(btn->parentWidget())) {
-        frame->setVisible(false);
-      }
-    }
-  }
-
-  // ── Dashcam panel ──
-  QWidget *dashcam_panel = new QWidget(this);
-  QVBoxLayout *dash_layout = new QVBoxLayout(dashcam_panel);
-  dash_layout->setContentsMargins(50, 25, 50, 25);
-  QLabel *dash_label = new QLabel("Dashcam viewer coming soon");
-  dash_label->setStyleSheet("color: grey; font-size: 40px;");
-  dash_label->setAlignment(Qt::AlignCenter);
-  dash_layout->addWidget(dash_label);
-  dash_layout->addStretch();
-
-  // ── Debug panel ──
-  ListWidget *debug_panel = new ListWidget(this);
-  debug_panel->setContentsMargins(50, 25, 50, 25);
-
-  auto *telemetry_toggle = new ToggleControl("Telemetry Logging",
-    "Record telemetry data to CSV in the session log directory. "
-    "Captures only changed values for efficiency.", "",
-    Params("/dev/shm/params").getBool("TelemetryEnabled"), this);
-  QObject::connect(telemetry_toggle, &ToggleControl::toggleFlipped, [](bool on) {
-    Params("/dev/shm/params").putBool("TelemetryEnabled", on);
-  });
-  debug_panel->addItem(telemetry_toggle);
-
-  auto *vpn_toggle = new ToggleControl("VPN",
-    "Connect to vpn.hanson.xyz for remote SSH access. "
-    "Disabling kills the active tunnel and stops reconnection attempts.", "",
-    Params("/dev/shm/params").getBool("VpnEnabled"), this);
-  QObject::connect(vpn_toggle, &ToggleControl::toggleFlipped, [](bool on) {
-    Params("/dev/shm/params").putBool("VpnEnabled", on);
-    if (on) {
-      std::system("sudo bash -c 'nohup /data/openpilot/system/clearpilot/vpn-monitor.sh >> /tmp/vpn-monitor.log 2>&1 &'");
-    } else {
-      std::system("sudo pkill -TERM -f vpn-monitor.sh; sudo killall openvpn");
-    }
-  });
-  debug_panel->addItem(vpn_toggle);
-
-  // ── Register panels with sidebar buttons ──
-  QList<QPair<QString, QWidget *>> panels = {
-    {"General", general_panel},
-    {"Network", network_panel},
-    {"Dashcam", dashcam_panel},
-    {"Debug", debug_panel},
-  };
-
-  nav_group = new QButtonGroup(this);
-  nav_group->setExclusive(true);
-
-  for (auto &[name, panel] : panels) {
-    QPushButton *btn = new QPushButton(name);
-    btn->setCheckable(true);
-    btn->setStyleSheet(clpSidebarBtnStyle);
-    btn->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
-    sidebar_layout->addWidget(btn, 0, Qt::AlignRight);
-    nav_group->addButton(btn);
-
-    // Network panel handles its own scrolling/margins
-    if (name == "Network") {
-      panel_widget->addWidget(panel);
-      QObject::connect(btn, &QPushButton::clicked, [=, w = panel]() {
-        panel_widget->setCurrentWidget(w);
-      });
-    } else {
-      ScrollView *panel_frame = new ScrollView(panel, this);
-      panel_widget->addWidget(panel_frame);
-      QObject::connect(btn, &QPushButton::clicked, [=, w = panel_frame]() {
-        panel_widget->setCurrentWidget(w);
-      });
-    }
-  }
-
-  // Select General by default
-  nav_group->buttons().first()->setChecked(true);
-  panel_widget->setCurrentIndex(0);
-
-  // Main layout: sidebar + panels
-  QHBoxLayout *main_layout = new QHBoxLayout(this);
-  sidebar_widget->setFixedWidth(500);
-  main_layout->addWidget(sidebar_widget);
-  main_layout->addWidget(panel_widget);
+  // set up refresh timer
+  timer = new QTimer(this);
+  timer->callOnTimeout(this, &OffroadHome::refresh);
 
   setStyleSheet(R"(
     * {
       color: white;
-      font-size: 50px;
     }
-    ClearPilotPanel {
+    OffroadHome {
       background-color: black;
     }
-    QStackedWidget, ScrollView, Networking {
-      background-color: #292929;
-      border-radius: 30px;
+    OffroadHome > QPushButton {
+      padding: 15px 30px;
+      border-radius: 5px;
+      font-size: 40px;
+      font-weight: 500;
+    }
+    OffroadHome > QLabel {
+      font-size: 55px;
     }
-    #softreboot_btn { height: 120px; border-radius: 15px; background-color: #e2e22c; }
-    #softreboot_btn:pressed { background-color: #ffe224; }
-    #reboot_btn { height: 120px; border-radius: 15px; background-color: #393939; }
-    #reboot_btn:pressed { background-color: #4a4a4a; }
-    #poweroff_btn { height: 120px; border-radius: 15px; background-color: #E22C2C; }
-    #poweroff_btn:pressed { background-color: #FF2424; }
   )");
 }
 
-void ClearPilotPanel::resetToGeneral() {
-  panel_widget->setCurrentIndex(0);
-  nav_group->buttons().first()->setChecked(true);
+/* Refresh data on screen every 5 seconds. */
+void OffroadHome::showEvent(QShowEvent *event) {
+  refresh();
+  timer->start(5 * 1000);
+}
+
+void OffroadHome::hideEvent(QHideEvent *event) {
+  timer->stop();
+}
+
+void OffroadHome::refresh() {
+  QString model = QString::fromStdString(params.get("ModelName"));
+
+  date->setText(QLocale(uiState()->language.mid(5)).toString(QDateTime::currentDateTime(), "dddd, MMMM d"));
+  version->setText(getBrand() + " v" + getVersion().left(14).trimmed() + " - " + model);
+
+  // bool updateAvailable = update_widget->refresh();
+
+  int alerts = alerts_widget->refresh();
+
+  if (alerts > 0 && !alerts_widget->isVisible()) {
+    alerts_widget->setVisible(true);
+  } else if (alerts == 0 && alerts_widget->isVisible()) {
+    alerts_widget->setVisible(false);
+  }
+
+  // pop-up new notification
+  // CLEARPILOT temp disabled update notifications
+  // int idx = center_layout->currentIndex();
+  // if (!updateAvailable && !alerts && false) {
+  //   idx = 0;
+  // } else if (updateAvailable && (!update_notif->isVisible() || (!alerts && idx == 2))) {
+  //   idx = 1;
+  // } else if (alerts && (!alert_notif->isVisible() || (!updateAvailable && idx == 1))) {
+  //   idx = 2;
+  // }
+  // center_layout->setCurrentIndex(idx);
+
+  // CLEARPILOT temp disabled update notifications
+//  update_notif->setVisible(updateAvailable);
+//  alert_notif->setVisible(alerts);
+  alert_notif->setVisible(false);
+  if (alerts) {
+    alert_notif->setText(QString::number(alerts) + (alerts > 1 ? tr(" ALERTS") : tr(" ALERT")));
+  }
 }

selfdrive/ui/qt/home.h

@@ -1,11 +1,9 @@
 #pragma once
 
-#include <QButtonGroup>
 #include <QFrame>
 #include <QLabel>
 #include <QPushButton>
 #include <QStackedLayout>
-#include <QStackedWidget>
 #include <QTimer>
 #include <QWidget>
 
@@ -18,23 +16,32 @@
 #include "selfdrive/ui/qt/widgets/offroad_alerts.h"
 #include "selfdrive/ui/ui.h"
 
-class ClearPilotPanel : public QFrame {
+class OffroadHome : public QFrame {
   Q_OBJECT
 
 public:
-  explicit ClearPilotPanel(QWidget* parent = 0);
+  explicit OffroadHome(QWidget* parent = 0);
 
 signals:
   void openSettings(int index = 0, const QString &param = "");
-  void openStatus();
-  void closePanel();
-
-public:
-  void resetToGeneral();
 
 private:
-  QStackedWidget *panel_widget;
-  QButtonGroup *nav_group;
+  void showEvent(QShowEvent *event) override;
+  void hideEvent(QHideEvent *event) override;
+  void refresh();
+
+  Params params;
+
+  QTimer* timer;
+  ElidedLabel* version;
+  QStackedLayout* center_layout;
+  UpdateAlert *update_widget;
+  OffroadAlert* alerts_widget;
+  QPushButton* alert_notif;
+  QPushButton* update_notif;
+
+  // FrogPilot variables
+  ElidedLabel* date;
 };
 
 class HomeWindow : public QWidget {
@@ -46,7 +53,6 @@ public:
 
 signals:
   void openSettings(int index = 0, const QString &param = "");
-  void openStatus();
   void closeSettings();
 
 public slots:
@@ -61,18 +67,17 @@ protected:
 
 private:
   Sidebar *sidebar;
-  ClearPilotPanel *home;
+  OffroadHome *home;
   OnroadWindow *onroad;
   DriverViewWindow *driver_view;
   QStackedLayout *slayout;
 
   // FrogPilot variables
   Params params;
-  Params paramsMemory{"/dev/shm/params"};
 
   // CLEARPILOT
+  // bool show_ready;
   ReadyWindow *ready;
-  bool was_parked_onroad = false;
 
 private slots:
   void updateState(const UIState &s);

selfdrive/ui/qt/onroad.cc

@@ -7,7 +7,6 @@
 #include <sstream>
 
 #include <QApplication>
-#include <QDateTime>
 #include <QDebug>
 #include <QMouseEvent>
 
@@ -76,10 +75,10 @@ void OnroadWindow::updateState(const UIState &s) {
   alerts->updateAlert(alert);
 
   nvg->updateState(s);
-  nvg->update();  // CLEARPILOT: force repaint every frame for HUD elements
 
   QColor bgColor = bg_colors[s.status];
-  if (paramsMemory.getBool("no_lat_lane_change") == 1) {
+  
+  if (paramsMemory.getBool("no_lat_lane_change") == 1 || nvg->screenDisplayMode == 2) {
     bgColor = bg_colors[STATUS_DISENGAGED];
   } 
 
@@ -177,14 +176,7 @@ void OnroadWindow::offroadTransition(bool offroad) {
 
 void OnroadWindow::paintEvent(QPaintEvent *event) {
   QPainter p(this);
-  // CLEARPILOT: hide engagement border in nightrider mode
-  int dm = paramsMemory.getInt("ScreenDisplayMode");
-  bool nightrider = (dm == 1 || dm == 4);
-  if (nightrider) {
-    p.fillRect(rect(), Qt::black);
-  } else {
-    p.fillRect(rect(), QColor(bg.red(), bg.green(), bg.blue(), 255));
-  }
+  p.fillRect(rect(), QColor(bg.red(), bg.green(), bg.blue(), 255));
 
   QString logicsDisplayString = QString();
   if (scene.show_jerk) {
@@ -224,13 +216,6 @@ void OnroadWindow::paintEvent(QPaintEvent *event) {
   }
 }
 
-// void OnroadWindow::update_screen_on_off() {
-//   int screenDisaplayMode = paramsMemory.getInt("ScreenDisaplayMode");
-//   if (screenDisaplayMode == 1) {
-//     // Conditionally off
-//   }
-// }
-
 
 // ***** onroad widgets *****
 
@@ -323,7 +308,10 @@ AnnotatedCameraWidget::AnnotatedCameraWidget(VisionStreamType type, QWidget* par
   QHBoxLayout *buttons_layout = new QHBoxLayout();
   buttons_layout->setSpacing(0);
 
-  // Neokii screen recorder — DISABLED: using dashcamd instead
+  // Neokii screen recorder
+  recorder_btn = new ScreenRecorder(this);
+  recorder_btn->setVisible(false);
+  // buttons_layout->addWidget(recorder_btn);
 
   QVBoxLayout *top_right_layout = new QVBoxLayout();
   top_right_layout->setSpacing(0);
@@ -339,13 +327,24 @@ AnnotatedCameraWidget::AnnotatedCameraWidget(VisionStreamType type, QWidget* par
 }
 
 void AnnotatedCameraWidget::updateState(const UIState &s) {
+
+  screenDisplayMode = paramsMemory.getInt("ScreenDisplayMode");
+  if (screenDisplayMode == 2 && !alert_is_visible) {
+    // Draw black, filled, full-size rectangle to blank the screen
+    // p.fillRect(0, 0, width(), height(), Qt::black);
+    // p.restore();
+    Hardware::set_display_power(false);
+    return;
+  } else {
+    Hardware::set_display_power(true);
+  }
+
   const int SET_SPEED_NA = 255;
   const SubMaster &sm = *(s.sm);
 
   const bool cs_alive = sm.alive("controlsState");
   const auto cs = sm["controlsState"].getControlsState();
   const auto car_state = sm["carState"].getCarState();
-  (void)car_state;  // CLEARPILOT: suppress unused warning, will use later
 
   // Handle older routes where vCruiseCluster is not set
   float v_cruise = cs.getVCruiseCluster() == 0.0 ? cs.getVCruise() : cs.getVCruiseCluster();
@@ -355,16 +354,11 @@ void AnnotatedCameraWidget::updateState(const UIState &s) {
     setSpeed *= KM_TO_MILE;
   }
 
-  // CLEARPILOT: read speed and speed limit from params (written by speed_logic.py ~2Hz)
-  clpParamFrame++;
-  if (clpParamFrame % 10 == 0) {  // ~2Hz at 20Hz UI update rate
-    clpHasSpeed = paramsMemory.get("ClearpilotHasSpeed") == "1";
-    clpSpeedDisplay = QString::fromStdString(paramsMemory.get("ClearpilotSpeedDisplay"));
-    clpSpeedLimitDisplay = QString::fromStdString(paramsMemory.get("ClearpilotSpeedLimitDisplay"));
-    clpSpeedUnit = QString::fromStdString(paramsMemory.get("ClearpilotSpeedUnit"));
-    clpCruiseWarning = QString::fromStdString(paramsMemory.get("ClearpilotCruiseWarning"));
-    clpCruiseWarningSpeed = QString::fromStdString(paramsMemory.get("ClearpilotCruiseWarningSpeed"));
-  }
+  // Handle older routes where vEgoCluster is not set
+  v_ego_cluster_seen = v_ego_cluster_seen || car_state.getVEgoCluster() != 0.0;
+  float v_ego = v_ego_cluster_seen && !scene.wheel_speed ? car_state.getVEgoCluster() : car_state.getVEgo();
+  speed = cs_alive ? std::max<float>(0.0, v_ego) : 0.0;
+  speed *= s.scene.is_metric ? MS_TO_KPH : MS_TO_MPH;
 
   // auto speed_limit_sign = nav_instruction.getSpeedLimitSign();
   // speedLimit = slcOverridden ? scene.speed_limit_overridden_speed : speedLimitController ? scene.speed_limit : nav_alive ? nav_instruction.getSpeedLimit() : 0.0;
@@ -400,28 +394,9 @@ if (edgeColor != bgColor) {
 }
 
 void AnnotatedCameraWidget::drawHud(QPainter &p) {
-  // CLEARPILOT: display power control based on ScreenDisplayMode
+  // Blank when screenDisplayMode=1
   p.save();
-
-  if (displayMode == 3 && !alert_is_visible) {
-    Hardware::set_display_power(false);
-    p.restore();
-    return;
-  } else {
-    Hardware::set_display_power(true);
-  }
-
-  // CLEARPILOT: blinking blue circle when telemetry is recording
-  if (paramsMemory.getBool("TelemetryEnabled")) {
-    // Blink: visible for 500ms, hidden for 500ms
-    int phase = (QDateTime::currentMSecsSinceEpoch() / 500) % 2;
-    if (phase == 0) {
-      p.setPen(Qt::NoPen);
-      p.setBrush(QColor(30, 100, 220));
-      p.drawEllipse(width() - 150, 50, 100, 100);
-    }
-  }
-
+  
   // Header gradient
   QLinearGradient bg(0, UI_HEADER_HEIGHT - (UI_HEADER_HEIGHT / 2.5), 0, UI_HEADER_HEIGHT);
   bg.setColorAt(0, QColor::fromRgbF(0, 0, 0, 0.45));
@@ -432,7 +407,7 @@ void AnnotatedCameraWidget::drawHud(QPainter &p) {
 
   // QString speedLimitStr = (speedLimit > 1) ? QString::number(std::nearbyint(speedLimit)) : "–";
   // QString speedLimitOffsetStr = slcSpeedLimitOffset == 0 ? "–" : QString::number(slcSpeedLimitOffset, 'f', 0).prepend(slcSpeedLimitOffset > 0 ? "+" : "");
-  // QString speedStr = QString::number(std::nearbyint(speed));
+  QString speedStr = QString::number(std::nearbyint(speed));
   QString setSpeedStr = is_cruise_set ? QString::number(std::nearbyint(setSpeed - cruiseAdjustment)) : "–";
 
   p.restore();
@@ -456,18 +431,17 @@ void AnnotatedCameraWidget::drawHud(QPainter &p) {
   // Todo: lead speed
   // Todo: Experimental speed
 
-  // CLEARPILOT: show speed from speed_logic params, hide when no speed or speed=0
-  if (clpHasSpeed && !clpSpeedDisplay.isEmpty() && !scene.hide_speed) {
+  // // current speed
+  if (!(scene.hide_speed)) {
+    // CLEARPILOT changes to 120 from ~176
+    // Maybe we want to hide this?
     p.setFont(InterFont(140, QFont::Bold));
-    drawText(p, rect().center().x(), 210, clpSpeedDisplay);
+    drawText(p, rect().center().x(), 210, speedStr);
+    // CLEARPILOT changes to 40 from 66
     p.setFont(InterFont(50));
-    drawText(p, rect().center().x(), 290, clpSpeedUnit, 200);
+    drawText(p, rect().center().x(), 290, speedUnit, 200);
   }
-
-  // CLEARPILOT: speed limit sign in lower-left, cruise warning above it
-  drawSpeedLimitSign(p);
-  drawCruiseWarningSign(p);
-
+  
   // Draw FrogPilot widgets
   paintFrogPilotWidgets(p);
 }
@@ -561,164 +535,6 @@ void AnnotatedCameraWidget::drawSpeedWidget(QPainter &p, int x, int y, const QSt
 }
 
 
-void AnnotatedCameraWidget::drawSpeedLimitSign(QPainter &p) {
-  // Hide when no speed limit or speed limit is 0
-  if (clpSpeedLimitDisplay.isEmpty() || clpSpeedLimitDisplay == "0") return;
-
-  p.save();
-
-  const int signW = 189;
-  const int signH = 239;
-  const int margin = 20;
-  const int borderW = 6;
-  const int innerBorderW = 4;
-  const int innerMargin = 10;
-  const int cornerR = 15;
-
-  // Position: 20px from lower-left corner
-  QRect signRect(margin, height() - signH - margin, signW, signH);
-
-  if (nightriderMode) {
-    // Nightrider: black background, light gray-blue border and text
-    QColor borderColor(160, 180, 210);
-    QColor textColor(160, 180, 210);
-
-    // Outer border
-    p.setPen(QPen(borderColor, borderW));
-    p.setBrush(QColor(0, 0, 0, 220));
-    p.drawRoundedRect(signRect, cornerR, cornerR);
-
-    // Inner border
-    QRect innerRect = signRect.adjusted(innerMargin, innerMargin, -innerMargin, -innerMargin);
-    p.setPen(QPen(borderColor, innerBorderW));
-    p.setBrush(Qt::NoBrush);
-    p.drawRoundedRect(innerRect, cornerR - 4, cornerR - 4);
-
-    // "SPEED" text
-    p.setPen(textColor);
-    p.setFont(InterFont(30, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 15, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "SPEED");
-
-    // "LIMIT" text
-    p.setFont(InterFont(30, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 48, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "LIMIT");
-
-    // Speed limit number
-    p.setFont(InterFont(90, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 42, 0, 0), Qt::AlignCenter, clpSpeedLimitDisplay);
-  } else {
-    // Normal: white background, black border and text
-    QColor borderColor(0, 0, 0);
-    QColor textColor(0, 0, 0);
-
-    // Outer border
-    p.setPen(QPen(borderColor, borderW));
-    p.setBrush(QColor(255, 255, 255, 240));
-    p.drawRoundedRect(signRect, cornerR, cornerR);
-
-    // Inner border
-    QRect innerRect = signRect.adjusted(innerMargin, innerMargin, -innerMargin, -innerMargin);
-    p.setPen(QPen(borderColor, innerBorderW));
-    p.setBrush(Qt::NoBrush);
-    p.drawRoundedRect(innerRect, cornerR - 4, cornerR - 4);
-
-    // "SPEED" text
-    p.setPen(textColor);
-    p.setFont(InterFont(30, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 15, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "SPEED");
-
-    // "LIMIT" text
-    p.setFont(InterFont(30, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 48, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "LIMIT");
-
-    // Speed limit number
-    p.setFont(InterFont(90, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 42, 0, 0), Qt::AlignCenter, clpSpeedLimitDisplay);
-  }
-
-  p.restore();
-}
-
-void AnnotatedCameraWidget::drawCruiseWarningSign(QPainter &p) {
-  // Only show when there's an active warning and the speed limit sign is visible
-  if (clpCruiseWarning.isEmpty() || clpCruiseWarningSpeed.isEmpty()) return;
-  if (clpSpeedLimitDisplay.isEmpty() || clpSpeedLimitDisplay == "0") return;
-
-  bool isOver = (clpCruiseWarning == "over");
-  if (!isOver && clpCruiseWarning != "under") return;
-
-  p.save();
-
-  // Same dimensions as speed limit sign
-  const int signW = 189;
-  const int signH = 239;
-  const int margin = 20;
-  const int borderW = 6;
-  const int innerBorderW = 4;
-  const int innerMargin = 10;
-  const int cornerR = 15;
-  const int gap = 20;
-
-  // Position: directly above the speed limit sign
-  int speedLimitY = height() - signH - margin;
-  QRect signRect(margin, speedLimitY - signH - gap, signW, signH);
-
-  if (nightriderMode) {
-    // Nightrider: black background with colored border/text
-    QColor accentColor = isOver ? QColor(220, 50, 50) : QColor(50, 180, 80);
-
-    p.setPen(QPen(accentColor, borderW));
-    p.setBrush(QColor(0, 0, 0, 220));
-    p.drawRoundedRect(signRect, cornerR, cornerR);
-
-    QRect innerRect = signRect.adjusted(innerMargin, innerMargin, -innerMargin, -innerMargin);
-    p.setPen(QPen(accentColor, innerBorderW));
-    p.setBrush(Qt::NoBrush);
-    p.drawRoundedRect(innerRect, cornerR - 4, cornerR - 4);
-
-    // "CRUISE" text
-    p.setPen(accentColor);
-    p.setFont(InterFont(26, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 15, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "CRUISE");
-
-    // "SET" text
-    p.setFont(InterFont(26, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 45, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "SET");
-
-    // Cruise speed number
-    p.setFont(InterFont(90, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 42, 0, 0), Qt::AlignCenter, clpCruiseWarningSpeed);
-  } else {
-    // Normal: colored background with white border/text
-    QColor bgColor = isOver ? QColor(200, 30, 30, 240) : QColor(40, 160, 60, 240);
-    QColor fgColor(255, 255, 255);
-
-    p.setPen(QPen(fgColor, borderW));
-    p.setBrush(bgColor);
-    p.drawRoundedRect(signRect, cornerR, cornerR);
-
-    QRect innerRect = signRect.adjusted(innerMargin, innerMargin, -innerMargin, -innerMargin);
-    p.setPen(QPen(fgColor, innerBorderW));
-    p.setBrush(Qt::NoBrush);
-    p.drawRoundedRect(innerRect, cornerR - 4, cornerR - 4);
-
-    // "CRUISE" text
-    p.setPen(fgColor);
-    p.setFont(InterFont(26, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 15, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "CRUISE");
-
-    // "SET" text
-    p.setFont(InterFont(26, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 45, 0, 0), Qt::AlignTop | Qt::AlignHCenter, "SET");
-
-    // Cruise speed number
-    p.setFont(InterFont(90, QFont::Bold));
-    p.drawText(innerRect.adjusted(0, 42, 0, 0), Qt::AlignCenter, clpCruiseWarningSpeed);
-  }
-
-  p.restore();
-}
-
 void AnnotatedCameraWidget::drawText(QPainter &p, int x, int y, const QString &text, int alpha) {
   QRect real_rect = p.fontMetrics().boundingRect(text);
   real_rect.moveCenter({x, y - real_rect.height() / 2});
@@ -746,6 +562,13 @@ void AnnotatedCameraWidget::updateFrameMat() {
   s->fb_w = w;
   s->fb_h = h;
 
+  if (screenDisplayMode == 1 || screenDisplayMode == 2) {
+    // Render a black box instead of the video feed
+    QPainter painter(this);
+    painter.fillRect(0, 0, w, h, Qt::black);
+    return;
+  }
+
   // Apply transformation such that video pixel coordinates match video
   // 1) Put (0, 0) in the middle of the video
   // 2) Apply same scaling as video
@@ -757,51 +580,27 @@ void AnnotatedCameraWidget::updateFrameMat() {
 }
 
 void AnnotatedCameraWidget::drawLaneLines(QPainter &painter, const UIState *s) {
+  if (screenDisplayMode == 2) {
+    return;
+  }
+  
   painter.save();
 
   // CLEARPILOT: color channel code rewriten to allow custom colors
 
   SubMaster &sm = *(s->sm);
 
-  // CLEARPILOT: nightrider mode — outline only, no fill
-  bool outlineOnly = nightriderMode;
-
-  // CLEARPILOT: in nightrider mode, hide all lines when not engaged
-  if (outlineOnly && edgeColor == bg_colors[STATUS_DISENGAGED]) {
-    painter.restore();
-    return;
-  }
-
-  // CLEARPILOT: nightrider lines are 1px wider (3 instead of 2)
-  int outlineWidth = outlineOnly ? 3 : 2;
-
   // lanelines
   for (int i = 0; i < std::size(scene.lane_line_vertices); ++i) {
-    QColor lineColor = QColor::fromRgbF(1.0, 1.0, 1.0, std::clamp<float>(scene.lane_line_probs[i], 0.0, 0.7));
-    if (outlineOnly) {
-      painter.setPen(QPen(lineColor, outlineWidth));
-      painter.setBrush(Qt::NoBrush);
-    } else {
-      painter.setPen(Qt::NoPen);
-      painter.setBrush(lineColor);
-    }
+      painter.setBrush(QColor::fromRgbF(1.0, 1.0, 1.0, std::clamp<float>(scene.lane_line_probs[i], 0.0, 0.7)));
     painter.drawPolygon(scene.lane_line_vertices[i]);
   }
-  if (outlineOnly) painter.setPen(Qt::NoPen);
 
   // road edges
   for (int i = 0; i < std::size(scene.road_edge_vertices); ++i) {
-    QColor edgeCol = QColor::fromRgbF(1.0, 0, 0, std::clamp<float>(1.0 - scene.road_edge_stds[i], 0.0, 1.0));
-    if (outlineOnly) {
-      painter.setPen(QPen(edgeCol, outlineWidth));
-      painter.setBrush(Qt::NoBrush);
-    } else {
-      painter.setPen(Qt::NoPen);
-      painter.setBrush(edgeCol);
-    }
+      painter.setBrush(QColor::fromRgbF(1.0, 0, 0, std::clamp<float>(1.0 - scene.road_edge_stds[i], 0.0, 1.0)));
     painter.drawPolygon(scene.road_edge_vertices[i]);
   }
-  if (outlineOnly) painter.setPen(Qt::NoPen);
 
   // paint center lane path
   // QColor bg_colors[CHANGE_LANE_PATH_COLOR];
@@ -866,20 +665,12 @@ void AnnotatedCameraWidget::drawLaneLines(QPainter &painter, const UIState *s) {
       path_gradient.setColorAt(1.0, QColor(center_lane_color.red(), center_lane_color.green(), center_lane_color.blue(), static_cast<int>(CENTER_LANE_ALPHA * 255 * 0.0)));
     }
 
-    if (outlineOnly) {
-      painter.setPen(QPen(QColor(center_lane_color.red(), center_lane_color.green(),
-                                 center_lane_color.blue(), 180), outlineWidth));
-      painter.setBrush(Qt::NoBrush);
-    } else {
-      painter.setPen(Qt::NoPen);
-      painter.setBrush(path_gradient);
-    }
+    painter.setBrush(path_gradient);
     painter.drawPolygon(scene.track_vertices);
-    if (outlineOnly) painter.setPen(Qt::NoPen);
   }
 
   // Paint path edges ,Use current background color
-  if (edgeColor != bg_colors[STATUS_DISENGAGED] && !outlineOnly) {
+  if (edgeColor != bg_colors[STATUS_DISENGAGED]) {
     QLinearGradient edge_gradient;
     edge_gradient.setColorAt(0.0, QColor(edgeColor.red(), edgeColor.green(), edgeColor.blue(), static_cast<int>(255)));  
     edge_gradient.setColorAt(0.5, QColor(edgeColor.red(), edgeColor.green(), edgeColor.blue(), static_cast<int>(255 * 0.8) ));  
@@ -895,24 +686,18 @@ void AnnotatedCameraWidget::drawLaneLines(QPainter &painter, const UIState *s) {
 
   // Paint blindspot path
   if (scene.blind_spot_path) {
-    QColor bsColor = QColor::fromHslF(0 / 360., 0.75, 0.50, 0.6);
-    if (outlineOnly) {
-      painter.setPen(QPen(bsColor, outlineWidth));
-      painter.setBrush(Qt::NoBrush);
-    } else {
-      QLinearGradient bs(0, height(), 0, 0);
-      bs.setColorAt(0.0, QColor::fromHslF(0 / 360., 0.75, 0.50, 0.6));
-      bs.setColorAt(0.5, QColor::fromHslF(0 / 360., 0.75, 0.50, 0.4));
-      bs.setColorAt(1.0, QColor::fromHslF(0 / 360., 0.75, 0.50, 0.2));
-      painter.setBrush(bs);
-    }
+    QLinearGradient bs(0, height(), 0, 0);
+    bs.setColorAt(0.0, QColor::fromHslF(0 / 360., 0.75, 0.50, 0.6));
+    bs.setColorAt(0.5, QColor::fromHslF(0 / 360., 0.75, 0.50, 0.4));
+    bs.setColorAt(1.0, QColor::fromHslF(0 / 360., 0.75, 0.50, 0.2));
+
+    painter.setBrush(bs);
     if (blindSpotLeft) {
       painter.drawPolygon(scene.track_adjacent_vertices[4]);
     }
     if (blindSpotRight) {
       painter.drawPolygon(scene.track_adjacent_vertices[5]);
     }
-    if (outlineOnly) painter.setPen(Qt::NoPen);
   }
 
   // Paint adjacent lane paths
@@ -923,19 +708,16 @@ void AnnotatedCameraWidget::drawLaneLines(QPainter &painter, const UIState *s) {
     float maxLaneWidth = laneDetectionWidth * 1.5;
 
     auto paintLane = [=](QPainter &painter, const QPolygonF &lane, float laneWidth, bool blindspot) {
+      QLinearGradient al(0, height(), 0, 0);
+
       bool redPath = laneWidth < minLaneWidth || laneWidth > maxLaneWidth || blindspot;
       float hue = redPath ? 0.0 : 120.0 * (laneWidth - minLaneWidth) / (maxLaneWidth - minLaneWidth);
 
-      if (outlineOnly) {
-        painter.setPen(QPen(QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.6), 2));
-        painter.setBrush(Qt::NoBrush);
-      } else {
-        QLinearGradient al(0, height(), 0, 0);
-        al.setColorAt(0.0, QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.6));
-        al.setColorAt(0.5, QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.4));
-        al.setColorAt(1.0, QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.2));
-        painter.setBrush(al);
-      }
+      al.setColorAt(0.0, QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.6));
+      al.setColorAt(0.5, QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.4));
+      al.setColorAt(1.0, QColor::fromHslF(hue / 360.0, 0.75, 0.50, 0.2));
+
+      painter.setBrush(al);
       painter.drawPolygon(lane);
 
       painter.setFont(InterFont(30, QFont::DemiBold));
@@ -1023,10 +805,6 @@ void AnnotatedCameraWidget::paintEvent(QPaintEvent *event) {
   const cereal::ModelDataV2::Reader &model = sm["modelV2"].getModelV2();
   const float v_ego = sm["carState"].getCarState().getVEgo();
 
-  // CLEARPILOT: read display mode early — needed for camera suppression
-  displayMode = paramsMemory.getInt("ScreenDisplayMode");
-  nightriderMode = (displayMode == 1 || displayMode == 4);
-
   // draw camera frame
   {
     std::lock_guard lk(frame_lock);
@@ -1067,19 +845,9 @@ void AnnotatedCameraWidget::paintEvent(QPaintEvent *event) {
     } else {
       CameraWidget::updateCalibration(DEFAULT_CALIBRATION);
     }
-    // CLEARPILOT: force CameraWidget bg to black in nightrider to prevent color bleed
-    if (nightriderMode) {
-      CameraWidget::setBackgroundColor(Qt::black);
-    }
     painter.beginNativePainting();
-    if (nightriderMode) {
-      // CLEARPILOT: black background, no camera feed
-      glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-      glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-    } else {
-      CameraWidget::setFrameId(model.getFrameId());
-      CameraWidget::paintGL();
-    }
+    CameraWidget::setFrameId(model.getFrameId());
+    CameraWidget::paintGL();
     painter.endNativePainting();
   }
 
@@ -1157,7 +925,7 @@ void AnnotatedCameraWidget::initializeFrogPilotWidgets() {
     animationFrameIndex = (animationFrameIndex + 1) % totalFrames;
   });
 
-  // CLEARPILOT: screen recorder disabled — replaced by dedicated dashcamd process
+  // Initialize the timer for the screen recorder
   // QTimer *record_timer = new QTimer(this);
   // connect(record_timer, &QTimer::timeout, this, [this]() {
   //   if (recorder_btn) {
@@ -1242,8 +1010,7 @@ void AnnotatedCameraWidget::updateFrogPilotWidgets() {
 }
 
 void AnnotatedCameraWidget::paintFrogPilotWidgets(QPainter &p) {
-  // CLEARPILOT: only show status bar when telemetry is enabled
-  if (paramsMemory.getBool("TelemetryEnabled")) {
+  if ((showAlwaysOnLateralStatusBar || showConditionalExperimentalStatusBar || roadNameUI)) {
     drawStatusBar(p);
   }
 
@@ -1255,7 +1022,8 @@ void AnnotatedCameraWidget::paintFrogPilotWidgets(QPainter &p) {
     drawSLCConfirmation(p);
   }
 
-  // CLEARPILOT: screen recorder disabled, using dashcamd instead
+  // recorder_btn->setVisible(scene.screen_recorder && !mapOpen);
+  recorder_btn->setVisible(false);
 }
 
 void AnnotatedCameraWidget::drawLeadInfo(QPainter &p) {
@@ -1444,30 +1212,7 @@ void AnnotatedCameraWidget::drawStatusBar(QPainter &p) {
 
   QString roadName = roadNameUI ? QString::fromStdString(paramsMemory.get("RoadName")) : QString();
 
-  // CLEARPILOT: telemetry status bar — show live stats when telemetry enabled
-  if (paramsMemory.getBool("TelemetryEnabled")) {
-    SubMaster &sm = *(uiState()->sm);
-    auto deviceState = sm["deviceState"].getDeviceState();
-    int maxTempC = deviceState.getMaxTempC();
-    int fanPct = deviceState.getFanSpeedPercentDesired();
-    bool standstill = sm["carState"].getCarState().getStandstill();
-
-    static double last_model_status_t = 0;
-    static float model_status_fps = 0;
-    if (sm.updated("modelV2")) {
-      double now = millis_since_boot();
-      if (last_model_status_t > 0) {
-        double dt = now - last_model_status_t;
-        if (dt > 0) model_status_fps = model_status_fps * 0.8 + (1000.0 / dt) * 0.2;
-      }
-      last_model_status_t = now;
-    }
-
-    newStatus = QString("%1\u00B0C  FAN %2%  MDL %3")
-      .arg(maxTempC).arg(fanPct).arg(model_status_fps, 0, 'f', 0);
-    if (standstill) newStatus += "  STANDSTILL";
-  // CLEARPILOT: suppress "Always On Lateral active" status bar message
-  } else if (false && alwaysOnLateralActive && showAlwaysOnLateralStatusBar) {
+  if (alwaysOnLateralActive && showAlwaysOnLateralStatusBar) {
     newStatus = tr("Always On Lateral active") + (tr(". Press the \"Cruise Control\" button to disable"));
   } else if (showConditionalExperimentalStatusBar) {
     newStatus = conditionalStatusMap[status != STATUS_DISENGAGED ? conditionalStatus : 0];

selfdrive/ui/qt/onroad.h

@@ -12,7 +12,7 @@
 #include "selfdrive/ui/ui.h"
 #include "selfdrive/ui/qt/widgets/cameraview.h"
 
-// #include "selfdrive/frogpilot/screenrecorder/screenrecorder.h"  // DISABLED: using dashcamd instead
+#include "selfdrive/frogpilot/screenrecorder/screenrecorder.h"
 
 const int btn_size = 192;
 const int img_size = (btn_size / 4) * 3;
@@ -47,30 +47,16 @@ public:
   explicit AnnotatedCameraWidget(VisionStreamType type, QWidget* parent = 0);
   void updateState(const UIState &s);
   void updateLaneEdgeColor(QColor &bgColor);
+  int screenDisplayMode = 0;
 
 private:
   void drawText(QPainter &p, int x, int y, const QString &text, int alpha = 255);
   void drawSpeedWidget(QPainter &p, int x, int y, const QString &title, const QString &speedLimitStr, QColor colorSpeed, int width = 176);
-  void drawSpeedLimitSign(QPainter &p);
-  void drawCruiseWarningSign(QPainter &p);
 
   QVBoxLayout *main_layout;
   QPixmap dm_img;
   float speed;
-  bool has_gps_speed = false;
-  bool nightriderMode = false;
-  int displayMode = 0;
   QString speedUnit;
-
-  // ClearPilot speed state (from params_memory, updated ~2Hz)
-  bool clpHasSpeed = false;
-  QString clpSpeedDisplay;
-  QString clpSpeedLimitDisplay;
-  QString clpSpeedUnit;
-  QString clpCruiseWarning;
-  QString clpCruiseWarningSpeed;
-  int clpParamFrame = 0;
-
   float setSpeed;
   float speedLimit;
   bool is_cruise_set = false;
@@ -103,6 +89,8 @@ private:
   Params paramsMemory{"/dev/shm/params"};
   UIScene &scene;
 
+  ScreenRecorder *recorder_btn;
+
   QHBoxLayout *bottom_layout;
 
   bool alwaysOnLateralActive;

selfdrive/ui/qt/ready.cc

@@ -30,12 +30,11 @@ ReadyWindow::ReadyWindow(QWidget *parent) : QWidget(parent) {
 
     timer = new QTimer(this);
     timer->callOnTimeout(this, &ReadyWindow::refresh);
-    uptime.start();
 }
 
 void ReadyWindow::showEvent(QShowEvent *event) {
   refresh();
-  timer->start(2 * 1000);
+  timer->start(5 * 1000);
 }
 
 void ReadyWindow::hideEvent(QHideEvent *event) {
@@ -44,94 +43,34 @@ void ReadyWindow::hideEvent(QHideEvent *event) {
 
 void ReadyWindow::paintEvent(QPaintEvent *event) {
     QPainter painter(this);
-    painter.fillRect(rect(), Qt::black);
+    QPixmap *img_shown = nullptr;
 
     if (is_hot) {
         if (img_hot.isNull()) {
             img_hot.load("/data/openpilot/selfdrive/clearpilot/theme/clearpilot/images/hot.png");
         }
-        int x = (width() - img_hot.width()) / 2;
-        int y = (height() - img_hot.height()) / 2;
-        painter.drawPixmap(x, y, img_hot);
+        img_shown = &img_hot;
     } else {
-        // Boot logo — same rotation as spinner (bg.jpg is pre-rotated 90° CW for framebuffer)
-        if (img_bg.isNull()) {
-            QPixmap raw("/usr/comma/bg.jpg");
-            if (!raw.isNull()) {
-                QTransform rot;
-                rot.rotate(-90);
-                img_bg = raw.transformed(rot);
-            }
-        }
-        if (!img_bg.isNull()) {
-            QPixmap scaled = img_bg.scaled(size(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
-            int x = (width() - scaled.width()) / 2;
-            int y = (height() - scaled.height()) / 2;
-            painter.drawPixmap(x, y, scaled);
-        }
-
-        if (error_msg.isEmpty() && !has_driven) {
-            // "READY!" 8-bit text sprite, 15% below center — only before first drive
-            static QPixmap ready_text("/data/openpilot/selfdrive/clearpilot/theme/clearpilot/images/ready_text.png");
-            if (!ready_text.isNull()) {
-                int tx = (width() - ready_text.width()) / 2;
-                int ty = height() / 2 + height() * 15 / 100;
-                painter.drawPixmap(tx, ty, ready_text);
-            }
-        } else {
-            // Error state: red text at 25% below center
-            QFont font("Inter", 50, QFont::Bold);
-            painter.setFont(font);
-            painter.setPen(QColor(0xFF, 0x44, 0x44));
-            int ty = height() / 2 + height() * 25 / 100;
-            QRect text_rect(0, ty, width(), 100);
-            painter.drawText(text_rect, Qt::AlignHCenter | Qt::AlignTop, error_msg);
+        if (img_ready.isNull()) {
+            img_ready.load("/data/openpilot/selfdrive/clearpilot/theme/clearpilot/images/ready.png");
         }
+        img_shown = &img_ready;
     }
+
+    int x = (width() - img_shown->width()) / 2;
+    int y = (height() - img_shown->height()) / 2;
+    painter.drawPixmap(x, y, *img_shown);
 }
 
 void ReadyWindow::refresh() {
-    bool changed = false;
-
-    // Temperature check
     std::string bytes = params.get("Offroad_TemperatureTooHigh");
-    bool was_hot = is_hot;
     if (!bytes.empty()) {
         auto doc = QJsonDocument::fromJson(bytes.data());
         is_hot = true;
         cur_temp = doc["extra"].toString();
-    } else {
+        update();
+    } else if (is_hot) {
         is_hot = false;
+        update();
     }
-    if (is_hot != was_hot) changed = true;
-
-    // Error state checks (only when not hot — hot has its own display)
-    if (!is_hot) {
-        QString prev_error = error_msg;
-
-        // Panda check — same logic as sidebar, with 10s grace period on startup
-        if (uptime.elapsed() > 10000 &&
-            uiState()->scene.pandaType == cereal::PandaState::PandaType::UNKNOWN) {
-            error_msg = "PANDA NOT CONNECTED";
-        }
-        // Car unrecognized check
-        else if (!params.get("Offroad_CarUnrecognized").empty()) {
-            error_msg = "CAR NOT RECOGNIZED";
-        }
-        else {
-            error_msg = "";
-        }
-
-        if (error_msg != prev_error) changed = true;
-    }
-
-    // Reset has_driven on ignition off→on (power cycle)
-    bool started = uiState()->scene.started;
-    if (!last_started && started) {
-      has_driven = false;
-      changed = true;
-    }
-    last_started = started;
-
-    if (changed) update();
 }

selfdrive/ui/qt/ready.h

@@ -8,9 +8,8 @@
 #include <QSocketNotifier>
 #include <QVariantAnimation>
 #include <QWidget>
-#include <QElapsedTimer>
 #include <QTimer>
-
+ 
 #include "common/util.h"
 #include "selfdrive/ui/ui.h"
 
@@ -18,7 +17,6 @@ class ReadyWindow : public QWidget {
     Q_OBJECT
 public:
     ReadyWindow(QWidget* parent = nullptr);
-    bool has_driven = false;
 private:
     void showEvent(QShowEvent *event) override;
     void hideEvent(QHideEvent *event) override;
@@ -28,9 +26,6 @@ private:
     QTimer* timer;
     bool is_hot = false;
     QString cur_temp;
-    QString error_msg;  // non-empty = show red error instead of READY!
-    QElapsedTimer uptime;
-    bool last_started = false;
-    QPixmap img_bg;
+    QPixmap img_ready;
     QPixmap img_hot;
 };

selfdrive/ui/qt/window.cc

@@ -1,9 +1,6 @@
 #include "selfdrive/ui/qt/window.h"
 
 #include <QFontDatabase>
-#include <QMouseEvent>
-
-#include <zmq.h>
 
 #include "system/hardware/hw.h"
 
@@ -14,7 +11,6 @@ MainWindow::MainWindow(QWidget *parent) : QWidget(parent) {
   homeWindow = new HomeWindow(this);
   main_layout->addWidget(homeWindow);
   QObject::connect(homeWindow, &HomeWindow::openSettings, this, &MainWindow::openSettings);
-  QObject::connect(homeWindow, &HomeWindow::openStatus, this, &MainWindow::openStatus);
   QObject::connect(homeWindow, &HomeWindow::closeSettings, this, &MainWindow::closeSettings);
 
   settingsWindow = new SettingsWindow(this);
@@ -28,11 +24,6 @@ MainWindow::MainWindow(QWidget *parent) : QWidget(parent) {
     homeWindow->showDriverView(true);
   });
 
-  // CLEARPILOT: Status window
-  statusWindow = new StatusWindow(this);
-  main_layout->addWidget(statusWindow);
-  QObject::connect(statusWindow, &StatusWindow::closeStatus, this, &MainWindow::closeSettings);
-
   onboardingWindow = new OnboardingWindow(this);
   main_layout->addWidget(onboardingWindow);
   QObject::connect(onboardingWindow, &OnboardingWindow::onboardingDone, [=]() {
@@ -44,17 +35,13 @@ MainWindow::MainWindow(QWidget *parent) : QWidget(parent) {
 
   QObject::connect(uiState(), &UIState::offroadTransition, [=](bool offroad) {
     if (!offroad) {
-      // CLEARPILOT: just switch to homeWindow, don't show sidebar
-      // HomeWindow::offroadTransition handles the internal view
-      main_layout->setCurrentWidget(homeWindow);
+      closeSettings();
     }
   });
   QObject::connect(device(), &Device::interactiveTimeout, [=]() {
-    // CLEARPILOT: on timeout, return to splash/onroad (not ClearPilotPanel)
-    if (main_layout->currentWidget() != homeWindow) {
-      main_layout->setCurrentWidget(homeWindow);
+    if (main_layout->currentWidget() == settingsWindow) {
+      closeSettings();
     }
-    homeWindow->offroadTransition(!uiState()->scene.started);
   });
 
   // load fonts
@@ -76,74 +63,6 @@ MainWindow::MainWindow(QWidget *parent) : QWidget(parent) {
     }
   )");
   setAttribute(Qt::WA_NoSystemBackground);
-
-  // CLEARPILOT: UI introspection RPC server
-  zmq_ctx = zmq_ctx_new();
-  zmq_sock = zmq_socket(zmq_ctx, ZMQ_REP);
-  zmq_bind(zmq_sock, "ipc:///tmp/clearpilot_ui_rpc");
-  int fd;
-  size_t fd_sz = sizeof(fd);
-  zmq_getsockopt(zmq_sock, ZMQ_FD, &fd, &fd_sz);
-  rpc_notifier = new QSocketNotifier(fd, QSocketNotifier::Read, this);
-  connect(rpc_notifier, &QSocketNotifier::activated, this, &MainWindow::handleRpcRequest);
-}
-
-void MainWindow::handleRpcRequest() {
-  int events = 0;
-  size_t events_sz = sizeof(events);
-  zmq_getsockopt(zmq_sock, ZMQ_EVENTS, &events, &events_sz);
-  if (!(events & ZMQ_POLLIN)) return;
-
-  char buf[256];
-  int rc = zmq_recv(zmq_sock, buf, sizeof(buf) - 1, ZMQ_DONTWAIT);
-  if (rc < 0) return;
-  buf[rc] = 0;
-
-  QString response;
-  if (strcmp(buf, "dump") == 0) {
-    response = dumpWidgetTree(this);
-  } else {
-    response = "unknown command";
-  }
-
-  QByteArray resp = response.toUtf8();
-  zmq_send(zmq_sock, resp.data(), resp.size(), 0);
-}
-
-QString MainWindow::dumpWidgetTree(QWidget *w, int depth) {
-  QString result;
-  QString indent(depth * 2, ' ');
-  QString className = w->metaObject()->className();
-  QString name = w->objectName().isEmpty() ? "(no name)" : w->objectName();
-  bool visible = w->isVisible();
-  QRect geo = w->geometry();
-
-  result += QString("%1%2 [%3] vis=%4 geo=%5,%6 %7x%8")
-    .arg(indent, className, name)
-    .arg(visible ? "Y" : "N")
-    .arg(geo.x()).arg(geo.y()).arg(geo.width()).arg(geo.height());
-
-  // Show stacked layout/widget current index
-  if (auto *sl = w->findChild<QStackedLayout *>(QString(), Qt::FindDirectChildrenOnly)) {
-    QWidget *cur = sl->currentWidget();
-    QString curClass = cur ? cur->metaObject()->className() : "null";
-    result += QString(" stack_cur=%1/%2(%3)").arg(sl->currentIndex()).arg(sl->count()).arg(curClass);
-  }
-  if (auto *sw = qobject_cast<QStackedWidget *>(w)) {
-    QWidget *cur = sw->currentWidget();
-    QString curClass = cur ? cur->metaObject()->className() : "null";
-    result += QString(" stack_cur=%1/%2(%3)").arg(sw->currentIndex()).arg(sw->count()).arg(curClass);
-  }
-
-  result += "\n";
-
-  for (QObject *child : w->children()) {
-    QWidget *cw = qobject_cast<QWidget *>(child);
-    if (cw && depth < 4) {
-      result += dumpWidgetTree(cw, depth + 1);
-    }
-  }
-  return result;
 }
 
 void MainWindow::openSettings(int index, const QString &param) {
@@ -151,10 +70,6 @@ void MainWindow::openSettings(int index, const QString &param) {
   settingsWindow->setCurrentPanel(index, param);
 }
 
-void MainWindow::openStatus() {
-  main_layout->setCurrentWidget(statusWindow);
-}
-
 void MainWindow::closeSettings() {
   main_layout->setCurrentWidget(homeWindow);
 
@@ -181,196 +96,3 @@ bool MainWindow::eventFilter(QObject *obj, QEvent *event) {
   }
   return ignore;
 }
-
-// CLEARPILOT: Status window — live system stats, collected on background thread
-
-#include <QFile>
-#include <QProcess>
-#include <QDateTime>
-#include <QtConcurrent>
-
-static QString readFile(const QString &path) {
-  QFile f(path);
-  if (f.open(QIODevice::ReadOnly)) return QString(f.readAll()).trimmed();
-  return "";
-}
-
-static QString shellCmd(const QString &cmd) {
-  QProcess p;
-  p.start("bash", QStringList() << "-c" << cmd);
-  p.waitForFinished(1000);
-  return QString(p.readAllStandardOutput()).trimmed();
-}
-
-static StatusWindow::StatusData collectStatus() {
-  StatusWindow::StatusData d;
-
-  d.time = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
-  d.storage = shellCmd("df -h /data | tail -1 | awk '{print $3 \" / \" $2 \" (\" $5 \" used)\"}'");
-
-  // RAM from /proc/meminfo (no subprocess needed)
-  QString meminfo = readFile("/proc/meminfo");
-  long total = 0, avail = 0;
-  for (const QString &line : meminfo.split('\n')) {
-    if (line.startsWith("MemTotal:")) total = line.split(QRegExp("\\s+"))[1].toLong();
-    if (line.startsWith("MemAvailable:")) avail = line.split(QRegExp("\\s+"))[1].toLong();
-  }
-  if (total > 0) {
-    long used = total - avail;
-    d.ram = QString("%1 / %2 MB").arg(used / 1024).arg(total / 1024);
-  }
-
-  // Load from /proc/loadavg
-  QString loadavg = readFile("/proc/loadavg");
-  QStringList parts = loadavg.split(' ');
-  if (parts.size() >= 3) {
-    d.load = QString("%1  %2  %3").arg(parts[0], parts[1], parts[2]);
-  }
-
-  // Temperature
-  QString temps = shellCmd("cat /sys/class/thermal/thermal_zone*/temp 2>/dev/null | sort -rn | head -1");
-  if (!temps.isEmpty()) {
-    d.temp_c = temps.toLong() / 1000.0f;
-    d.temp = QString("%1\u00B0C").arg(d.temp_c, 0, 'f', 1);
-  }
-
-  // Fan
-  QString fan = shellCmd("cat /sys/class/hwmon/hwmon*/fan1_input 2>/dev/null | head -1");
-  if (fan.isEmpty()) fan = readFile("/dev/shm/params/d/LastFanSpeed");
-  d.fan = fan.isEmpty() ? QString::fromUtf8("\u2014") : fan + " RPM";
-
-  // Network
-  d.ip = shellCmd("ip route get 1.1.1.1 2>/dev/null | head -1 | awk '{print $7}'");
-  d.wifi = shellCmd("iwconfig wlan0 2>/dev/null | grep -oP 'ESSID:\"\\K[^\"]*'");
-
-  // VPN
-  QString tun = shellCmd("ip link show tun0 2>/dev/null | head -1");
-  if (tun.contains("UP")) {
-    d.vpn_status = "up";
-    d.vpn_ip = shellCmd("ip addr show tun0 2>/dev/null | grep 'inet ' | awk '{print $2}'");
-  }
-
-  // GPS
-  d.gps = readFile("/data/params/d/LastGPSPosition");
-
-  // Telemetry
-  d.telemetry = readFile("/data/params/d/TelemetryEnabled");
-
-  // Panda: checked on UI thread in applyResults() via scene.pandaType
-
-  return d;
-}
-
-StatusWindow::StatusWindow(QWidget *parent) : QFrame(parent) {
-  QVBoxLayout *layout = new QVBoxLayout(this);
-  layout->setContentsMargins(50, 60, 50, 40);
-  layout->setSpacing(0);
-
-  // Status rows
-  auto makeRow = [&](const QString &label) -> QLabel* {
-    QHBoxLayout *row = new QHBoxLayout();
-    row->setContentsMargins(20, 0, 20, 0);
-
-    QLabel *name = new QLabel(label);
-    name->setStyleSheet("color: grey; font-size: 38px;");
-    name->setFixedWidth(350);
-    row->addWidget(name);
-
-    QLabel *value = new QLabel("—");
-    value->setStyleSheet("color: white; font-size: 38px;");
-    row->addWidget(value);
-    row->addStretch();
-
-    layout->addLayout(row);
-    layout->addSpacing(12);
-    return value;
-  };
-
-  time_label = makeRow("Time");
-  storage_label = makeRow("Storage");
-  ram_label = makeRow("Memory");
-  load_label = makeRow("Load");
-  temp_label = makeRow("Temperature");
-  fan_label = makeRow("Fan Speed");
-  panda_label = makeRow("Panda");
-  ip_label = makeRow("IP Address");
-  wifi_label = makeRow("WiFi");
-  vpn_label = makeRow("VPN");
-  gps_label = makeRow("GPS");
-  telemetry_label = makeRow("Telemetry");
-
-  layout->addStretch();
-
-  setStyleSheet("StatusWindow { background-color: black; }");
-
-  connect(&watcher, &QFutureWatcher<StatusData>::finished, this, &StatusWindow::applyResults);
-
-  QTimer *timer = new QTimer(this);
-  connect(timer, &QTimer::timeout, this, &StatusWindow::kickRefresh);
-  timer->start(1000);
-}
-
-void StatusWindow::kickRefresh() {
-  if (!isVisible() || collecting) return;
-  collecting = true;
-  watcher.setFuture(QtConcurrent::run(collectStatus));
-}
-
-void StatusWindow::applyResults() {
-  collecting = false;
-  StatusData d = watcher.result();
-
-  time_label->setText(d.time);
-  storage_label->setText(d.storage);
-  if (!d.ram.isEmpty()) ram_label->setText(d.ram);
-  if (!d.load.isEmpty()) load_label->setText(d.load);
-
-  if (!d.temp.isEmpty()) {
-    temp_label->setText(d.temp);
-    temp_label->setStyleSheet(d.temp_c > 70 ? "color: #ff4444; font-size: 38px;" :
-                              d.temp_c > 55 ? "color: #ffaa00; font-size: 38px;" :
-                                              "color: white; font-size: 38px;");
-  }
-
-  fan_label->setText(d.fan);
-
-  // Panda: same check as sidebar — read scene.pandaType on UI thread
-  if (uiState()->scene.pandaType != cereal::PandaState::PandaType::UNKNOWN) {
-    panda_label->setText("Connected");
-    panda_label->setStyleSheet("color: #17c44d; font-size: 38px;");
-  } else {
-    panda_label->setText("Not connected");
-    panda_label->setStyleSheet("color: #ff4444; font-size: 38px;");
-  }
-
-  ip_label->setText(d.ip.isEmpty() ? "No connection" : d.ip);
-  wifi_label->setText(d.wifi.isEmpty() ? "Not connected" : d.wifi);
-
-  if (d.vpn_status == "up") {
-    vpn_label->setText("Connected (" + d.vpn_ip + ")");
-    vpn_label->setStyleSheet("color: #17c44d; font-size: 38px;");
-  } else {
-    vpn_label->setText("Not connected");
-    vpn_label->setStyleSheet("color: #ff4444; font-size: 38px;");
-  }
-
-  if (d.gps.isEmpty()) {
-    gps_label->setText("No fix");
-    gps_label->setStyleSheet("color: #ff4444; font-size: 38px;");
-  } else {
-    gps_label->setText(d.gps);
-    gps_label->setStyleSheet("color: white; font-size: 38px;");
-  }
-
-  if (d.telemetry == "1") {
-    telemetry_label->setText("Enabled");
-    telemetry_label->setStyleSheet("color: #17c44d; font-size: 38px;");
-  } else {
-    telemetry_label->setText("Disabled");
-    telemetry_label->setStyleSheet("color: grey; font-size: 38px;");
-  }
-}
-
-void StatusWindow::mousePressEvent(QMouseEvent *e) {
-  emit closeStatus();
-}

selfdrive/ui/qt/window.h

@@ -1,57 +1,12 @@
 #pragma once
 
-#include <QFutureWatcher>
 #include <QStackedLayout>
-#include <QLabel>
-#include <QSocketNotifier>
-#include <QTimer>
 #include <QWidget>
 
 #include "selfdrive/ui/qt/home.h"
 #include "selfdrive/ui/qt/offroad/onboarding.h"
 #include "selfdrive/ui/qt/offroad/settings.h"
 
-class StatusWindow : public QFrame {
-  Q_OBJECT
-
-public:
-  explicit StatusWindow(QWidget *parent = 0);
-
-  struct StatusData {
-    QString time, storage, ram, load, temp, fan, ip, wifi;
-    QString vpn_status, vpn_ip, gps, telemetry;
-    float temp_c = 0;
-  };
-
-protected:
-  void mousePressEvent(QMouseEvent *e) override;
-
-signals:
-  void closeStatus();
-
-private slots:
-  void kickRefresh();
-  void applyResults();
-
-private:
-
-  QFutureWatcher<StatusData> watcher;
-  bool collecting = false;
-
-  QLabel *storage_label;
-  QLabel *ram_label;
-  QLabel *load_label;
-  QLabel *temp_label;
-  QLabel *fan_label;
-  QLabel *ip_label;
-  QLabel *wifi_label;
-  QLabel *vpn_label;
-  QLabel *gps_label;
-  QLabel *time_label;
-  QLabel *telemetry_label;
-  QLabel *panda_label;
-};
-
 class MainWindow : public QWidget {
   Q_OBJECT
 
@@ -61,24 +16,13 @@ public:
 private:
   bool eventFilter(QObject *obj, QEvent *event) override;
   void openSettings(int index = 0, const QString &param = "");
-  void openStatus();
   void closeSettings();
-  QString dumpWidgetTree(QWidget *w, int depth = 0);
 
   QStackedLayout *main_layout;
   HomeWindow *homeWindow;
   SettingsWindow *settingsWindow;
-  StatusWindow *statusWindow;
   OnboardingWindow *onboardingWindow;
 
-  // CLEARPILOT: UI introspection RPC
-  void *zmq_ctx = nullptr;
-  void *zmq_sock = nullptr;
-  QSocketNotifier *rpc_notifier = nullptr;
-
   // FrogPilot variables
   Params params;
-
-private slots:
-  void handleRpcRequest();
 };

selfdrive/ui/soundd.py

@@ -93,27 +93,6 @@ class Soundd:
 
     self.spl_filter_weighted = FirstOrderFilter(0, 2.5, FILTER_DT, initialized=False)
 
-    # ClearPilot ding (plays independently of alerts)
-    self.ding_sound = None
-    self.ding_frame = 0
-    self.ding_playing = False
-    self.ding_check_counter = 0
-    self._load_ding()
-
-  def _load_ding(self):
-    ding_path = BASEDIR + "/selfdrive/clearpilot/sounds/ding.wav"
-    try:
-      wavefile = wave.open(ding_path, 'r')
-      assert wavefile.getnchannels() == 1
-      assert wavefile.getsampwidth() == 2
-      assert wavefile.getframerate() == SAMPLE_RATE
-      length = wavefile.getnframes()
-      self.ding_sound = np.frombuffer(wavefile.readframes(length), dtype=np.int16).astype(np.float32) / (2**16/2)
-      cloudlog.info(f"ClearPilot ding loaded: {length} frames")
-    except Exception as e:
-      cloudlog.error(f"Failed to load ding sound: {e}")
-      self.ding_sound = None
-
   def load_sounds(self):
     self.loaded_sounds: dict[int, np.ndarray] = {}
 
@@ -158,20 +137,7 @@ class Soundd:
         written_frames += frames_to_write
         self.current_sound_frame += frames_to_write
 
-    ret = ret * self.current_volume
-
-    # Mix in ClearPilot ding (independent of alerts, always max volume)
-    if self.ding_playing and self.ding_sound is not None:
-      ding_remaining = len(self.ding_sound) - self.ding_frame
-      if ding_remaining > 0:
-        frames_to_write = min(ding_remaining, frames)
-        ret[:frames_to_write] += self.ding_sound[self.ding_frame:self.ding_frame + frames_to_write] * MAX_VOLUME
-        self.ding_frame += frames_to_write
-      else:
-        self.ding_playing = False
-        self.ding_frame = 0
-
-    return ret
+    return ret * self.current_volume
 
   def callback(self, data_out: np.ndarray, frames: int, time, status) -> None:
     if status:
@@ -231,14 +197,6 @@ class Soundd:
 
         self.get_audible_alert(sm)
 
-        # ClearPilot: check for ding trigger at ~2Hz
-        self.ding_check_counter += 1
-        if self.ding_check_counter % 10 == 0 and self.ding_sound is not None:
-          if self.params_memory.get("ClearpilotPlayDing") == b"1":
-            self.params_memory.put("ClearpilotPlayDing", "0")
-            self.ding_playing = True
-            self.ding_frame = 0
-
         rk.keep_time()
 
         assert stream.active

selfdrive/ui/spinner

@@ -1,10 +1,5 @@
 #!/bin/sh
 
-# CLEARPILOT: prefer freshly built _spinner over prebuilt qt/spinner
-if [ -f ./_spinner ]; then
-  exec ./_spinner "$1"
-fi
-
 if [ -f /TICI ] && [ ! -f qt/spinner ]; then
   cp qt/spinner_larch64 qt/spinner
 fi

selfdrive/ui/translations/main_ar.ts

@@ -818,15 +818,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">تحديث</translation>
+        <translation>تحديث</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> التنبهات</translation>
+        <translation> التنبهات</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> تنبيه</translation>
+        <translation> تنبيه</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_de.ts

@@ -771,15 +771,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">Aktualisieren</translation>
+        <translation>Aktualisieren</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> HINWEISE</translation>
+        <translation> HINWEISE</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> HINWEIS</translation>
+        <translation> HINWEIS</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_fr.ts

@@ -814,15 +814,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">MISE À JOUR</translation>
+        <translation>MISE À JOUR</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> ALERTES</translation>
+        <translation> ALERTES</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> ALERTE</translation>
+        <translation> ALERTE</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_ja.ts

@@ -770,15 +770,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">更新</translation>
+        <translation>更新</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> 警告</translation>
+        <translation> 警告</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> 警告</translation>
+        <translation> 警告</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_ko.ts

@@ -813,15 +813,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">업데이트</translation>
+        <translation>업데이트</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> 알림</translation>
+        <translation> 알림</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> 알림</translation>
+        <translation> 알림</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_pt-BR.ts

@@ -814,15 +814,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">ATUALIZAÇÃO</translation>
+        <translation>ATUALIZAÇÃO</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> ALERTAS</translation>
+        <translation> ALERTAS</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> ALERTA</translation>
+        <translation> ALERTA</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_th.ts

@@ -813,15 +813,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">อัปเดต</translation>
+        <translation>อัปเดต</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> การแจ้งเตือน</translation>
+        <translation> การแจ้งเตือน</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> การแจ้งเตือน</translation>
+        <translation> การแจ้งเตือน</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_tr.ts

@@ -770,15 +770,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">GÜNCELLE</translation>
+        <translation>GÜNCELLE</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> UYARILAR</translation>
+        <translation> UYARILAR</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> UYARI</translation>
+        <translation> UYARI</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_zh-CHS.ts

@@ -813,15 +813,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">更新</translation>
+        <translation>更新</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> 警报</translation>
+        <translation> 警报</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> 警报</translation>
+        <translation> 警报</translation>
     </message>
 </context>
 <context>

selfdrive/ui/translations/main_zh-CHT.ts

@@ -813,15 +813,15 @@
     <name>OffroadHome</name>
     <message>
         <source>UPDATE</source>
-        <translation type="vanished">更新</translation>
+        <translation>更新</translation>
     </message>
     <message>
         <source> ALERTS</source>
-        <translation type="vanished"> 提醒</translation>
+        <translation> 提醒</translation>
     </message>
     <message>
         <source> ALERT</source>
-        <translation type="vanished"> 提醒</translation>
+        <translation> 提醒</translation>
     </message>
 </context>
 <context>

selfdrive/ui/ui.cc

@@ -93,9 +93,6 @@ void update_model(UIState *s,
   if (plan_position.getX().size() < model.getPosition().getX().size()) {
     plan_position = model.getPosition();
   }
-  // CLEARPILOT: guard against empty model data (bench mode, no modeld running)
-  if (plan_position.getX().size() == 0) return;
-
   float max_distance = scene.unlimited_road_ui_length ? *(plan_position.getX().end() - 1) :
                        std::clamp(*(plan_position.getX().end() - 1),
                                   MIN_DRAW_DISTANCE, MAX_DRAW_DISTANCE);
@@ -394,7 +391,6 @@ void ui_update_frogpilot_params(UIState *s) {
   scene.screen_brightness = screen_management ? params.getInt("ScreenBrightness") : 101;
   scene.screen_brightness_onroad = screen_management ? params.getInt("ScreenBrightnessOnroad") : 101;
   scene.screen_recorder = screen_management && params.getBool("ScreenRecorder");
-  scene.screen_recorder_debug = params.getBool("ScreenRecorderDebug");
   scene.screen_timeout = screen_management ? params.getInt("ScreenTimeout") : 120;
   scene.screen_timeout_onroad = screen_management ? params.getInt("ScreenTimeoutOnroad") : 10;
   scene.standby_mode = screen_management && params.getBool("StandbyMode");
@@ -442,7 +438,6 @@ UIState::UIState(QObject *parent) : QObject(parent) {
     "pandaStates", "carParams", "driverMonitoringState", "carState", "liveLocationKalman", "driverStateV2",
     "wideRoadCameraState", "managerState", "uiPlan", "liveTorqueParameters",
     "frogpilotCarControl", "frogpilotDeviceState", "frogpilotPlan",
-    "gpsLocation",
   });
 
   Params params;
@@ -565,10 +560,7 @@ void Device::updateWakefulness(const UIState &s) {
     emit interactiveTimeout();
   }
 
-  // CLEARPILOT: ScreenDisplayMode 3 = screen off — override awake state
-  if (paramsMemory.getInt("ScreenDisplayMode") == 3) {
-    setAwake(false);
-  } else if (s.scene.screen_brightness_onroad != 0) {
+  if (s.scene.screen_brightness_onroad != 0) {
     setAwake(s.scene.ignition || interactive_timeout > 0);
   } else {
     setAwake(interactive_timeout > 0);

selfdrive/ui/ui.h

@@ -231,7 +231,6 @@ typedef struct UIScene {
   bool road_name_ui;
   bool rotating_wheel;
   bool screen_recorder;
-  bool screen_recorder_debug;
   bool show_aol_status_bar;
   bool show_cem_status_bar;
   bool show_jerk;

system/camerad/main.cc

@@ -7,27 +7,17 @@
 #include "system/hardware/hw.h"
 
 int main(int argc, char *argv[]) {
-  fprintf(stderr, "camerad: starting\n");
-
   if (Hardware::PC()) {
-    fprintf(stderr, "camerad: exiting, not meant to run on PC\n");
+    printf("exiting, camerad is not meant to run on PC\n");
     return 0;
   }
 
   int ret;
-  fprintf(stderr, "camerad: setting realtime priority 53\n");
   ret = util::set_realtime_priority(53);
-  fprintf(stderr, "camerad: set_realtime_priority ret=%d\n", ret);
   assert(ret == 0);
-
-  fprintf(stderr, "camerad: setting core affinity to cpu6\n");
   ret = util::set_core_affinity({6});
-  bool isOffroad = Params().getBool("IsOffroad");
-  fprintf(stderr, "camerad: set_core_affinity ret=%d, IsOffroad=%d\n", ret, isOffroad);
-  assert(ret == 0 || isOffroad); // failure ok while offroad due to offlining cores
+  assert(ret == 0 || Params().getBool("IsOffroad")); // failure ok while offroad due to offlining cores
 
-  fprintf(stderr, "camerad: starting camerad_thread\n");
   camerad_thread();
-  fprintf(stderr, "camerad: camerad_thread returned\n");
   return 0;
 }

system/clearpilot/gpsd.py

@@ -1,228 +0,0 @@
-#!/usr/bin/env python3
-"""
-ClearPilot GPS daemon — reads GPS from Quectel EC25 modem via AT commands
-and publishes gpsLocation messages for locationd/timed.
-
-Replaces qcomgpsd which uses the diag interface (broken on this device).
-"""
-import math
-import os
-import subprocess
-import time
-import datetime
-
-from cereal import log
-import cereal.messaging as messaging
-from openpilot.common.gpio import gpio_init, gpio_set
-from openpilot.common.params import Params
-from openpilot.common.swaglog import cloudlog
-from openpilot.common.time import system_time_valid
-from openpilot.system.hardware.tici.pins import GPIO
-
-
-def is_daylight(lat: float, lon: float, utc_dt: datetime.datetime) -> bool:
-  """Return True if it's between sunrise and sunset at the given location.
-  Uses NOAA simplified solar position equations. Pure math, no external libs."""
-  n = utc_dt.timetuple().tm_yday
-  gamma = 2 * math.pi / 365 * (n - 1 + (utc_dt.hour - 12) / 24)
-  # Equation of time (minutes)
-  eqtime = 229.18 * (0.000075 + 0.001868 * math.cos(gamma)
-           - 0.032077 * math.sin(gamma)
-           - 0.014615 * math.cos(2 * gamma)
-           - 0.040849 * math.sin(2 * gamma))
-  # Solar declination (radians)
-  decl = (0.006918 - 0.399912 * math.cos(gamma)
-          + 0.070257 * math.sin(gamma)
-          - 0.006758 * math.cos(2 * gamma)
-          + 0.000907 * math.sin(2 * gamma)
-          - 0.002697 * math.cos(3 * gamma)
-          + 0.00148 * math.sin(3 * gamma))
-  lat_rad = math.radians(lat)
-  zenith = math.radians(90.833)
-  cos_ha = (math.cos(zenith) / (math.cos(lat_rad) * math.cos(decl))
-            - math.tan(lat_rad) * math.tan(decl))
-  if cos_ha < -1:
-    return True   # midnight sun
-  if cos_ha > 1:
-    return False  # polar night
-  ha = math.degrees(math.acos(cos_ha))
-  sunrise_min = 720 - 4 * (lon + ha) - eqtime
-  sunset_min = 720 - 4 * (lon - ha) - eqtime
-  now_min = utc_dt.hour * 60 + utc_dt.minute + utc_dt.second / 60
-  return sunrise_min <= now_min <= sunset_min
-
-
-def at_cmd(cmd: str) -> str:
-  try:
-    result = subprocess.check_output(
-      f"mmcli -m any --timeout 10 --command='{cmd}'",
-      shell=True, encoding='utf8', stderr=subprocess.DEVNULL
-    ).strip()
-    # mmcli wraps AT responses: response: '+QGPSLOC: ...'
-    # Strip the wrapper to get just the AT response
-    if result.startswith("response: '") and result.endswith("'"):
-      result = result[len("response: '"):-1]
-    return result
-  except subprocess.CalledProcessError:
-    return ""
-
-
-def wait_for_modem():
-  cloudlog.warning("gpsd: waiting for modem")
-  while True:
-    ret = subprocess.call(
-      "mmcli -m any --timeout 10 --command='AT+QGPS?'",
-      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, shell=True
-    )
-    if ret == 0:
-      return
-    time.sleep(0.5)
-
-
-def parse_qgpsloc(response: str):
-  """Parse AT+QGPSLOC=2 response into a dict.
-  Format: +QGPSLOC: UTC,lat,lon,hdop,alt,fix,cog,spkm,spkn,date,nsat
-  """
-  if "+QGPSLOC:" not in response:
-    return None
-  try:
-    data = response.split("+QGPSLOC:")[1].strip()
-    fields = data.split(",")
-    if len(fields) < 11:
-      return None
-
-    utc = fields[0]       # HHMMSS.S
-    lat = float(fields[1])
-    lon = float(fields[2])
-    hdop = float(fields[3])
-    alt = float(fields[4])
-    fix = int(fields[5])  # 2=2D, 3=3D
-    cog = float(fields[6])  # course over ground
-    spkm = float(fields[7])  # speed km/h
-    spkn = float(fields[8])  # speed knots
-    date = fields[9]      # DDMMYY
-    nsat = int(fields[10])
-
-    # Build unix timestamp from UTC + date
-    # utc: "HHMMSS.S", date: "DDMMYY"
-    hh, mm = int(utc[0:2]), int(utc[2:4])
-    ss = float(utc[4:])
-    dd, mo, yy = int(date[0:2]), int(date[2:4]), 2000 + int(date[4:6])
-    dt = datetime.datetime(yy, mo, dd, hh, mm, int(ss),
-                           int((ss % 1) * 1e6), datetime.timezone.utc)
-
-    return {
-      "latitude": lat,
-      "longitude": lon,
-      "altitude": alt,
-      "speed": spkm / 3.6,  # convert km/h to m/s
-      "bearing": cog,
-      "accuracy": hdop * 5,  # rough conversion from HDOP to meters
-      "timestamp_ms": dt.timestamp() * 1e3,
-      "satellites": nsat,
-      "fix": fix,
-    }
-  except (ValueError, IndexError) as e:
-    cloudlog.error(f"gpsd: parse error: {e}")
-    return None
-
-
-def main():
-  import sys
-  print("gpsd: starting", file=sys.stderr, flush=True)
-
-  # Kill system gpsd which may respawn and interfere with modem access
-  subprocess.run("pkill -f /usr/sbin/gpsd", shell=True,
-                 stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-  wait_for_modem()
-  print("gpsd: modem ready", file=sys.stderr, flush=True)
-
-  # Enable GPS antenna power
-  gpio_init(GPIO.GNSS_PWR_EN, True)
-  gpio_set(GPIO.GNSS_PWR_EN, True)
-  print("gpsd: GPIO power enabled", file=sys.stderr, flush=True)
-
-  # Don't restart GPS if already running (preserve existing fix)
-  resp = at_cmd("AT+QGPS?")
-  print(f"gpsd: QGPS status: {resp}", file=sys.stderr, flush=True)
-  if "QGPS: 1" not in resp:
-    at_cmd('AT+QGPSCFG="dpoenable",0')
-    at_cmd('AT+QGPSCFG="outport","none"')
-    at_cmd("AT+QGPS=1")
-    print("gpsd: GPS started fresh", file=sys.stderr, flush=True)
-  else:
-    print("gpsd: GPS already running, keeping fix", file=sys.stderr, flush=True)
-
-  pm = messaging.PubMaster(["gpsLocation"])
-  clock_set = system_time_valid()
-  params_memory = Params("/dev/shm/params")
-  last_daylight_check = 0.0
-  daylight_computed = False
-  print("gpsd: entering main loop", file=sys.stderr, flush=True)
-
-  while True:
-    resp = at_cmd("AT+QGPSLOC=2")
-    fix = parse_qgpsloc(resp)
-
-    if fix:
-      # Set system clock from GPS on first valid fix if clock is invalid
-      if not clock_set:
-        gps_dt = datetime.datetime.utcfromtimestamp(fix["timestamp_ms"] / 1000)
-        ret = subprocess.run(["date", "-s", gps_dt.strftime("%Y-%m-%d %H:%M:%S")],
-                             env={**os.environ, "TZ": "UTC"},
-                             capture_output=True)
-        if ret.returncode == 0:
-          clock_set = True
-          cloudlog.warning("gpsd: system clock set from GPS: %s", gps_dt)
-          print(f"gpsd: system clock set from GPS: {gps_dt}", file=sys.stderr, flush=True)
-        else:
-          cloudlog.error("gpsd: failed to set clock: %s", ret.stderr.decode().strip())
-
-      msg = messaging.new_message("gpsLocation", valid=True)
-      gps = msg.gpsLocation
-      gps.latitude = fix["latitude"]
-      gps.longitude = fix["longitude"]
-      gps.altitude = fix["altitude"]
-      gps.speed = fix["speed"]
-      gps.bearingDeg = fix["bearing"]
-      gps.horizontalAccuracy = fix["accuracy"]
-      gps.unixTimestampMillis = int(fix["timestamp_ms"])
-      gps.source = log.GpsLocationData.SensorSource.qcomdiag
-      gps.hasFix = fix["fix"] >= 2
-      gps.flags = 1
-      gps.vNED = [0.0, 0.0, 0.0]
-      gps.verticalAccuracy = fix["accuracy"]
-      gps.bearingAccuracyDeg = 10.0
-      gps.speedAccuracy = 1.0
-      pm.send("gpsLocation", msg)
-
-      # CLEARPILOT: daylight calculation for auto display mode switching
-      if clock_set:
-        now_mono = time.monotonic()
-        interval = 1.0 if not daylight_computed else 30.0
-        if (now_mono - last_daylight_check) >= interval:
-          last_daylight_check = now_mono
-          utc_now = datetime.datetime.utcfromtimestamp(fix["timestamp_ms"] / 1000)
-          daylight = is_daylight(fix["latitude"], fix["longitude"], utc_now)
-          params_memory.put_bool("IsDaylight", daylight)
-
-          if not daylight_computed:
-            daylight_computed = True
-            cloudlog.warning("gpsd: initial daylight calc: %s", "day" if daylight else "night")
-            print(f"gpsd: initial daylight calc: {'day' if daylight else 'night'}", file=sys.stderr, flush=True)
-
-          # Auto-transition: only touch states 0 and 1
-          current_mode = params_memory.get_int("ScreenDisplayMode")
-          if current_mode == 0 and not daylight:
-            params_memory.put_int("ScreenDisplayMode", 1)
-            cloudlog.warning("gpsd: auto-switch to nightrider (sunset)")
-          elif current_mode == 1 and daylight:
-            params_memory.put_int("ScreenDisplayMode", 0)
-            cloudlog.warning("gpsd: auto-switch to normal (sunrise)")
-
-    time.sleep(1.0)  # 1 Hz polling
-
-
-if __name__ == "__main__":
-  main()

system/hardware/tici/hardware.h

@@ -50,6 +50,7 @@ public:
   }
 
   static void reboot() { std::system("sudo reboot"); }
+  
   static void soft_reboot() {
     const std::vector<std::string> commands = {
       "rm -f /tmp/safe_staging_overlay.lock",
@@ -67,7 +68,9 @@ public:
       }
     }
   }
+
   static void poweroff() { std::system("sudo poweroff"); }
+
   static void set_brightness(int percent) {
     std::string max = util::read_file("/sys/class/backlight/panel0-backlight/max_brightness");
 
@@ -77,6 +80,7 @@ public:
       brightness_control.close();
     }
   }
+  
   static void set_display_power(bool on) {
     std::ofstream bl_power_control("/sys/class/backlight/panel0-backlight/bl_power");
     if (bl_power_control.is_open()) {

system/loggerd/deleter.py

@@ -8,15 +8,11 @@ from openpilot.system.loggerd.config import get_available_bytes, get_available_p
 from openpilot.system.loggerd.uploader import listdir_by_creation
 from openpilot.system.loggerd.xattr_cache import getxattr
 
-# CLEARPILOT: increased from 5 GB to 9 GB to reserve space for screen recordings
-MIN_BYTES = 9 * 1024 * 1024 * 1024
+MIN_BYTES = 5 * 1024 * 1024 * 1024
 MIN_PERCENT = 10
 
 DELETE_LAST = ['boot', 'crash']
 
-# CLEARPILOT: screen recorder video directory
-VIDEOS_DIR = '/data/media/0/videos'
-
 PRESERVE_ATTR_NAME = 'user.preserve'
 PRESERVE_ATTR_VALUE = b'1'
 PRESERVE_COUNT = 5
@@ -48,103 +44,12 @@ def get_preserved_segments(dirs_by_creation: list[str]) -> list[str]:
   return preserved
 
 
-def delete_oldest_video():
-  """CLEARPILOT: delete oldest dashcam footage when disk space is low.
-  Trip directories are /data/media/0/videos/YYYYMMDD-HHMMSS/ containing .mp4 segments.
-  Deletes entire oldest trip directory first. If only one trip remains (active),
-  deletes individual segments oldest-first within it. Also cleans up legacy flat .mp4 files."""
-  try:
-    if not os.path.isdir(VIDEOS_DIR):
-      return False
-
-    # Collect legacy flat mp4 files and trip directories
-    legacy_files = []
-    trip_dirs = []
-    for entry in os.listdir(VIDEOS_DIR):
-      path = os.path.join(VIDEOS_DIR, entry)
-      if os.path.isfile(path) and entry.endswith('.mp4'):
-        legacy_files.append(entry)
-      elif os.path.isdir(path):
-        trip_dirs.append(entry)
-
-    # Delete legacy flat files first (oldest by name)
-    if legacy_files:
-      legacy_files.sort()
-      delete_path = os.path.join(VIDEOS_DIR, legacy_files[0])
-      cloudlog.info(f"deleting legacy video {delete_path}")
-      os.remove(delete_path)
-      return True
-
-    if not trip_dirs:
-      return False
-
-    trip_dirs.sort()  # sorted by timestamp name = chronological order
-
-    # If more than one trip, delete the oldest entire trip directory
-    if len(trip_dirs) > 1:
-      delete_path = os.path.join(VIDEOS_DIR, trip_dirs[0])
-      cloudlog.info(f"deleting trip {delete_path}")
-      shutil.rmtree(delete_path)
-      return True
-
-    # Only one trip left (likely active) — delete oldest segment within it
-    trip_path = os.path.join(VIDEOS_DIR, trip_dirs[0])
-    segments = sorted(f for f in os.listdir(trip_path) if f.endswith('.mp4'))
-    if not segments:
-      return False
-    delete_path = os.path.join(trip_path, segments[0])
-    cloudlog.info(f"deleting segment {delete_path}")
-    os.remove(delete_path)
-    return True
-  except OSError:
-    cloudlog.exception(f"issue deleting video from {VIDEOS_DIR}")
-    return False
-
-
-# CLEARPILOT: max total size for /data/log2 session logs
-LOG2_MAX_BYTES = 4 * 1024 * 1024 * 1024
-
-def cleanup_log2():
-  """Delete oldest session log directories until /data/log2 is under LOG2_MAX_BYTES."""
-  log_base = "/data/log2"
-  if not os.path.isdir(log_base):
-    return
-  # Get all session dirs sorted oldest first (by name = timestamp)
-  dirs = []
-  for entry in sorted(os.listdir(log_base)):
-    if entry == "current":
-      continue
-    path = os.path.join(log_base, entry)
-    if os.path.isdir(path) and not os.path.islink(path):
-      size = sum(f.stat().st_size for f in os.scandir(path) if f.is_file())
-      dirs.append((entry, path, size))
-  total = sum(s for _, _, s in dirs)
-  # Also count current session
-  current = os.path.join(log_base, "current")
-  if os.path.isdir(current):
-    total += sum(f.stat().st_size for f in os.scandir(current) if f.is_file())
-  # Delete oldest until under quota
-  while total > LOG2_MAX_BYTES and dirs:
-    entry, path, size = dirs.pop(0)
-    try:
-      cloudlog.info(f"deleting log session {path} ({size // 1024 // 1024} MB)")
-      shutil.rmtree(path)
-      total -= size
-    except OSError:
-      cloudlog.exception(f"issue deleting log {path}")
-
-
 def deleter_thread(exit_event):
   while not exit_event.is_set():
     out_of_bytes = get_available_bytes(default=MIN_BYTES + 1) < MIN_BYTES
     out_of_percent = get_available_percent(default=MIN_PERCENT + 1) < MIN_PERCENT
 
     if out_of_percent or out_of_bytes:
-      # CLEARPILOT: try deleting oldest video first, then fall back to log segments
-      if delete_oldest_video():
-        exit_event.wait(.1)
-        continue
-
       dirs = listdir_by_creation(Paths.log_root())
 
       # skip deleting most recent N preserved segments (and their prior segment)
@@ -168,8 +73,6 @@ def deleter_thread(exit_event):
           cloudlog.exception(f"issue deleting {delete_path}")
       exit_event.wait(.1)
     else:
-      # CLEARPILOT: enforce log2 size quota even when disk space is fine
-      cleanup_log2()
       exit_event.wait(30)
 
 

third_party/acados/larch64/lib/libqpOASES_e.so

@@ -0,0 +1 @@
+libqpOASES_e.so.3.1

third_party/acados/x86_64/lib/libqpOASES_e.so

@@ -0,0 +1 @@
+libqpOASES_e.so.3.1

third_party/libyuv/x86_64/include

@@ -0,0 +1 @@
+../include

third_party/libyuv/x86_64/include/libyuv.h

@@ -1,32 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_H_
-#define INCLUDE_LIBYUV_H_
-
-#include "libyuv/basic_types.h"
-#include "libyuv/compare.h"
-#include "libyuv/convert.h"
-#include "libyuv/convert_argb.h"
-#include "libyuv/convert_from.h"
-#include "libyuv/convert_from_argb.h"
-#include "libyuv/cpu_id.h"
-#include "libyuv/mjpeg_decoder.h"
-#include "libyuv/planar_functions.h"
-#include "libyuv/rotate.h"
-#include "libyuv/rotate_argb.h"
-#include "libyuv/row.h"
-#include "libyuv/scale.h"
-#include "libyuv/scale_argb.h"
-#include "libyuv/scale_row.h"
-#include "libyuv/version.h"
-#include "libyuv/video_common.h"
-
-#endif  // INCLUDE_LIBYUV_H_

third_party/libyuv/x86_64/include/libyuv/basic_types.h

@@ -1,118 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_BASIC_TYPES_H_
-#define INCLUDE_LIBYUV_BASIC_TYPES_H_
-
-#include <stddef.h>  // for NULL, size_t
-
-#if defined(_MSC_VER) && (_MSC_VER < 1600)
-#include <sys/types.h>  // for uintptr_t on x86
-#else
-#include <stdint.h>  // for uintptr_t
-#endif
-
-#ifndef GG_LONGLONG
-#ifndef INT_TYPES_DEFINED
-#define INT_TYPES_DEFINED
-#ifdef COMPILER_MSVC
-typedef unsigned __int64 uint64;
-typedef __int64 int64;
-#ifndef INT64_C
-#define INT64_C(x) x ## I64
-#endif
-#ifndef UINT64_C
-#define UINT64_C(x) x ## UI64
-#endif
-#define INT64_F "I64"
-#else  // COMPILER_MSVC
-#if defined(__LP64__) && !defined(__OpenBSD__) && !defined(__APPLE__)
-typedef unsigned long uint64;  // NOLINT
-typedef long int64;  // NOLINT
-#ifndef INT64_C
-#define INT64_C(x) x ## L
-#endif
-#ifndef UINT64_C
-#define UINT64_C(x) x ## UL
-#endif
-#define INT64_F "l"
-#else  // defined(__LP64__) && !defined(__OpenBSD__) && !defined(__APPLE__)
-typedef unsigned long long uint64;  // NOLINT
-typedef long long int64;  // NOLINT
-#ifndef INT64_C
-#define INT64_C(x) x ## LL
-#endif
-#ifndef UINT64_C
-#define UINT64_C(x) x ## ULL
-#endif
-#define INT64_F "ll"
-#endif  // __LP64__
-#endif  // COMPILER_MSVC
-typedef unsigned int uint32;
-typedef int int32;
-typedef unsigned short uint16;  // NOLINT
-typedef short int16;  // NOLINT
-typedef unsigned char uint8;
-typedef signed char int8;
-#endif  // INT_TYPES_DEFINED
-#endif  // GG_LONGLONG
-
-// Detect compiler is for x86 or x64.
-#if defined(__x86_64__) || defined(_M_X64) || \
-    defined(__i386__) || defined(_M_IX86)
-#define CPU_X86 1
-#endif
-// Detect compiler is for ARM.
-#if defined(__arm__) || defined(_M_ARM)
-#define CPU_ARM 1
-#endif
-
-#ifndef ALIGNP
-#ifdef __cplusplus
-#define ALIGNP(p, t) \
-    (reinterpret_cast<uint8*>(((reinterpret_cast<uintptr_t>(p) + \
-    ((t) - 1)) & ~((t) - 1))))
-#else
-#define ALIGNP(p, t) \
-    ((uint8*)((((uintptr_t)(p) + ((t) - 1)) & ~((t) - 1))))  /* NOLINT */
-#endif
-#endif
-
-#if !defined(LIBYUV_API)
-#if defined(_WIN32) || defined(__CYGWIN__)
-#if defined(LIBYUV_BUILDING_SHARED_LIBRARY)
-#define LIBYUV_API __declspec(dllexport)
-#elif defined(LIBYUV_USING_SHARED_LIBRARY)
-#define LIBYUV_API __declspec(dllimport)
-#else
-#define LIBYUV_API
-#endif  // LIBYUV_BUILDING_SHARED_LIBRARY
-#elif defined(__GNUC__) && (__GNUC__ >= 4) && !defined(__APPLE__) && \
-    (defined(LIBYUV_BUILDING_SHARED_LIBRARY) || \
-    defined(LIBYUV_USING_SHARED_LIBRARY))
-#define LIBYUV_API __attribute__ ((visibility ("default")))
-#else
-#define LIBYUV_API
-#endif  // __GNUC__
-#endif  // LIBYUV_API
-
-#define LIBYUV_BOOL int
-#define LIBYUV_FALSE 0
-#define LIBYUV_TRUE 1
-
-// Visual C x86 or GCC little endian.
-#if defined(__x86_64__) || defined(_M_X64) || \
-  defined(__i386__) || defined(_M_IX86) || \
-  defined(__arm__) || defined(_M_ARM) || \
-  (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-#define LIBYUV_LITTLE_ENDIAN
-#endif
-
-#endif  // INCLUDE_LIBYUV_BASIC_TYPES_H_

third_party/libyuv/x86_64/include/libyuv/compare.h

@@ -1,78 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_COMPARE_H_
-#define INCLUDE_LIBYUV_COMPARE_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Compute a hash for specified memory. Seed of 5381 recommended.
-LIBYUV_API
-uint32 HashDjb2(const uint8* src, uint64 count, uint32 seed);
-
-// Scan an opaque argb image and return fourcc based on alpha offset.
-// Returns FOURCC_ARGB, FOURCC_BGRA, or 0 if unknown.
-LIBYUV_API
-uint32 ARGBDetect(const uint8* argb, int stride_argb, int width, int height);
-
-// Sum Square Error - used to compute Mean Square Error or PSNR.
-LIBYUV_API
-uint64 ComputeSumSquareError(const uint8* src_a,
-                             const uint8* src_b, int count);
-
-LIBYUV_API
-uint64 ComputeSumSquareErrorPlane(const uint8* src_a, int stride_a,
-                                  const uint8* src_b, int stride_b,
-                                  int width, int height);
-
-static const int kMaxPsnr = 128;
-
-LIBYUV_API
-double SumSquareErrorToPsnr(uint64 sse, uint64 count);
-
-LIBYUV_API
-double CalcFramePsnr(const uint8* src_a, int stride_a,
-                     const uint8* src_b, int stride_b,
-                     int width, int height);
-
-LIBYUV_API
-double I420Psnr(const uint8* src_y_a, int stride_y_a,
-                const uint8* src_u_a, int stride_u_a,
-                const uint8* src_v_a, int stride_v_a,
-                const uint8* src_y_b, int stride_y_b,
-                const uint8* src_u_b, int stride_u_b,
-                const uint8* src_v_b, int stride_v_b,
-                int width, int height);
-
-LIBYUV_API
-double CalcFrameSsim(const uint8* src_a, int stride_a,
-                     const uint8* src_b, int stride_b,
-                     int width, int height);
-
-LIBYUV_API
-double I420Ssim(const uint8* src_y_a, int stride_y_a,
-                const uint8* src_u_a, int stride_u_a,
-                const uint8* src_v_a, int stride_v_a,
-                const uint8* src_y_b, int stride_y_b,
-                const uint8* src_u_b, int stride_u_b,
-                const uint8* src_v_b, int stride_v_b,
-                int width, int height);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_COMPARE_H_

third_party/libyuv/x86_64/include/libyuv/compare_row.h

@@ -1,84 +0,0 @@
-/*
- *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_COMPARE_ROW_H_
-#define INCLUDE_LIBYUV_COMPARE_ROW_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-#if defined(__pnacl__) || defined(__CLR_VER) || \
-    (defined(__i386__) && !defined(__SSE2__))
-#define LIBYUV_DISABLE_X86
-#endif
-// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#define LIBYUV_DISABLE_X86
-#endif
-#endif
-
-// Visual C 2012 required for AVX2.
-#if defined(_M_IX86) && !defined(__clang__) && \
-    defined(_MSC_VER) && _MSC_VER >= 1700
-#define VISUALC_HAS_AVX2 1
-#endif  // VisualStudio >= 2012
-
-// clang >= 3.4.0 required for AVX2.
-#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
-#if (__clang_major__ > 3) || (__clang_major__ == 3 && (__clang_minor__ >= 4))
-#define CLANG_HAS_AVX2 1
-#endif  // clang >= 3.4
-#endif  // __clang__
-
-#if !defined(LIBYUV_DISABLE_X86) && \
-    defined(_M_IX86) && (defined(VISUALC_HAS_AVX2) || defined(CLANG_HAS_AVX2))
-#define HAS_HASHDJB2_AVX2
-#endif
-
-// The following are available for Visual C and GCC:
-#if !defined(LIBYUV_DISABLE_X86) && \
-    (defined(__x86_64__) || (defined(__i386__) || defined(_M_IX86)))
-#define HAS_HASHDJB2_SSE41
-#define HAS_SUMSQUAREERROR_SSE2
-#endif
-
-// The following are available for Visual C and clangcl 32 bit:
-#if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86) && \
-    (defined(VISUALC_HAS_AVX2) || defined(CLANG_HAS_AVX2))
-#define HAS_HASHDJB2_AVX2
-#define HAS_SUMSQUAREERROR_AVX2
-#endif
-
-// The following are available for Neon:
-#if !defined(LIBYUV_DISABLE_NEON) && \
-    (defined(__ARM_NEON__) || defined(LIBYUV_NEON) || defined(__aarch64__))
-#define HAS_SUMSQUAREERROR_NEON
-#endif
-
-uint32 SumSquareError_C(const uint8* src_a, const uint8* src_b, int count);
-uint32 SumSquareError_SSE2(const uint8* src_a, const uint8* src_b, int count);
-uint32 SumSquareError_AVX2(const uint8* src_a, const uint8* src_b, int count);
-uint32 SumSquareError_NEON(const uint8* src_a, const uint8* src_b, int count);
-
-uint32 HashDjb2_C(const uint8* src, int count, uint32 seed);
-uint32 HashDjb2_SSE41(const uint8* src, int count, uint32 seed);
-uint32 HashDjb2_AVX2(const uint8* src, int count, uint32 seed);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_COMPARE_ROW_H_

third_party/libyuv/x86_64/include/libyuv/convert.h

@@ -1,259 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_CONVERT_H_
-#define INCLUDE_LIBYUV_CONVERT_H_
-
-#include "libyuv/basic_types.h"
-
-#include "libyuv/rotate.h"  // For enum RotationMode.
-
-// TODO(fbarchard): fix WebRTC source to include following libyuv headers:
-#include "libyuv/convert_argb.h"  // For WebRTC I420ToARGB. b/620
-#include "libyuv/convert_from.h"  // For WebRTC ConvertFromI420. b/620
-#include "libyuv/planar_functions.h"  // For WebRTC I420Rect, CopyPlane. b/618
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Convert I444 to I420.
-LIBYUV_API
-int I444ToI420(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert I422 to I420.
-LIBYUV_API
-int I422ToI420(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert I411 to I420.
-LIBYUV_API
-int I411ToI420(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Copy I420 to I420.
-#define I420ToI420 I420Copy
-LIBYUV_API
-int I420Copy(const uint8* src_y, int src_stride_y,
-             const uint8* src_u, int src_stride_u,
-             const uint8* src_v, int src_stride_v,
-             uint8* dst_y, int dst_stride_y,
-             uint8* dst_u, int dst_stride_u,
-             uint8* dst_v, int dst_stride_v,
-             int width, int height);
-
-// Convert I400 (grey) to I420.
-LIBYUV_API
-int I400ToI420(const uint8* src_y, int src_stride_y,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-#define J400ToJ420 I400ToI420
-
-// Convert NV12 to I420.
-LIBYUV_API
-int NV12ToI420(const uint8* src_y, int src_stride_y,
-               const uint8* src_uv, int src_stride_uv,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert NV21 to I420.
-LIBYUV_API
-int NV21ToI420(const uint8* src_y, int src_stride_y,
-               const uint8* src_vu, int src_stride_vu,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert YUY2 to I420.
-LIBYUV_API
-int YUY2ToI420(const uint8* src_yuy2, int src_stride_yuy2,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert UYVY to I420.
-LIBYUV_API
-int UYVYToI420(const uint8* src_uyvy, int src_stride_uyvy,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert M420 to I420.
-LIBYUV_API
-int M420ToI420(const uint8* src_m420, int src_stride_m420,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert Android420 to I420.
-LIBYUV_API
-int Android420ToI420(const uint8* src_y, int src_stride_y,
-                     const uint8* src_u, int src_stride_u,
-                     const uint8* src_v, int src_stride_v,
-                     int pixel_stride_uv,
-                     uint8* dst_y, int dst_stride_y,
-                     uint8* dst_u, int dst_stride_u,
-                     uint8* dst_v, int dst_stride_v,
-                     int width, int height);
-
-// ARGB little endian (bgra in memory) to I420.
-LIBYUV_API
-int ARGBToI420(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// BGRA little endian (argb in memory) to I420.
-LIBYUV_API
-int BGRAToI420(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// ABGR little endian (rgba in memory) to I420.
-LIBYUV_API
-int ABGRToI420(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// RGBA little endian (abgr in memory) to I420.
-LIBYUV_API
-int RGBAToI420(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// RGB little endian (bgr in memory) to I420.
-LIBYUV_API
-int RGB24ToI420(const uint8* src_frame, int src_stride_frame,
-                uint8* dst_y, int dst_stride_y,
-                uint8* dst_u, int dst_stride_u,
-                uint8* dst_v, int dst_stride_v,
-                int width, int height);
-
-// RGB big endian (rgb in memory) to I420.
-LIBYUV_API
-int RAWToI420(const uint8* src_frame, int src_stride_frame,
-              uint8* dst_y, int dst_stride_y,
-              uint8* dst_u, int dst_stride_u,
-              uint8* dst_v, int dst_stride_v,
-              int width, int height);
-
-// RGB16 (RGBP fourcc) little endian to I420.
-LIBYUV_API
-int RGB565ToI420(const uint8* src_frame, int src_stride_frame,
-                 uint8* dst_y, int dst_stride_y,
-                 uint8* dst_u, int dst_stride_u,
-                 uint8* dst_v, int dst_stride_v,
-                 int width, int height);
-
-// RGB15 (RGBO fourcc) little endian to I420.
-LIBYUV_API
-int ARGB1555ToI420(const uint8* src_frame, int src_stride_frame,
-                   uint8* dst_y, int dst_stride_y,
-                   uint8* dst_u, int dst_stride_u,
-                   uint8* dst_v, int dst_stride_v,
-                   int width, int height);
-
-// RGB12 (R444 fourcc) little endian to I420.
-LIBYUV_API
-int ARGB4444ToI420(const uint8* src_frame, int src_stride_frame,
-                   uint8* dst_y, int dst_stride_y,
-                   uint8* dst_u, int dst_stride_u,
-                   uint8* dst_v, int dst_stride_v,
-                   int width, int height);
-
-#ifdef HAVE_JPEG
-// src_width/height provided by capture.
-// dst_width/height for clipping determine final size.
-LIBYUV_API
-int MJPGToI420(const uint8* sample, size_t sample_size,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int src_width, int src_height,
-               int dst_width, int dst_height);
-
-// Query size of MJPG in pixels.
-LIBYUV_API
-int MJPGSize(const uint8* sample, size_t sample_size,
-             int* width, int* height);
-#endif
-
-// Convert camera sample to I420 with cropping, rotation and vertical flip.
-// "src_size" is needed to parse MJPG.
-// "dst_stride_y" number of bytes in a row of the dst_y plane.
-//   Normally this would be the same as dst_width, with recommended alignment
-//   to 16 bytes for better efficiency.
-//   If rotation of 90 or 270 is used, stride is affected. The caller should
-//   allocate the I420 buffer according to rotation.
-// "dst_stride_u" number of bytes in a row of the dst_u plane.
-//   Normally this would be the same as (dst_width + 1) / 2, with
-//   recommended alignment to 16 bytes for better efficiency.
-//   If rotation of 90 or 270 is used, stride is affected.
-// "crop_x" and "crop_y" are starting position for cropping.
-//   To center, crop_x = (src_width - dst_width) / 2
-//              crop_y = (src_height - dst_height) / 2
-// "src_width" / "src_height" is size of src_frame in pixels.
-//   "src_height" can be negative indicating a vertically flipped image source.
-// "crop_width" / "crop_height" is the size to crop the src to.
-//    Must be less than or equal to src_width/src_height
-//    Cropping parameters are pre-rotation.
-// "rotation" can be 0, 90, 180 or 270.
-// "format" is a fourcc. ie 'I420', 'YUY2'
-// Returns 0 for successful; -1 for invalid parameter. Non-zero for failure.
-LIBYUV_API
-int ConvertToI420(const uint8* src_frame, size_t src_size,
-                  uint8* dst_y, int dst_stride_y,
-                  uint8* dst_u, int dst_stride_u,
-                  uint8* dst_v, int dst_stride_v,
-                  int crop_x, int crop_y,
-                  int src_width, int src_height,
-                  int crop_width, int crop_height,
-                  enum RotationMode rotation,
-                  uint32 format);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_CONVERT_H_

third_party/libyuv/x86_64/include/libyuv/convert_argb.h

@@ -1,319 +0,0 @@
-/*
- *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_CONVERT_ARGB_H_
-#define INCLUDE_LIBYUV_CONVERT_ARGB_H_
-
-#include "libyuv/basic_types.h"
-
-#include "libyuv/rotate.h"  // For enum RotationMode.
-
-// TODO(fbarchard): This set of functions should exactly match convert.h
-// TODO(fbarchard): Add tests. Create random content of right size and convert
-// with C vs Opt and or to I420 and compare.
-// TODO(fbarchard): Some of these functions lack parameter setting.
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Alias.
-#define ARGBToARGB ARGBCopy
-
-// Copy ARGB to ARGB.
-LIBYUV_API
-int ARGBCopy(const uint8* src_argb, int src_stride_argb,
-             uint8* dst_argb, int dst_stride_argb,
-             int width, int height);
-
-// Convert I420 to ARGB.
-LIBYUV_API
-int I420ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Duplicate prototype for function in convert_from.h for remoting.
-LIBYUV_API
-int I420ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert I422 to ARGB.
-LIBYUV_API
-int I422ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert I444 to ARGB.
-LIBYUV_API
-int I444ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert J444 to ARGB.
-LIBYUV_API
-int J444ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert I444 to ABGR.
-LIBYUV_API
-int I444ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// Convert I411 to ARGB.
-LIBYUV_API
-int I411ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert I420 with Alpha to preattenuated ARGB.
-LIBYUV_API
-int I420AlphaToARGB(const uint8* src_y, int src_stride_y,
-                    const uint8* src_u, int src_stride_u,
-                    const uint8* src_v, int src_stride_v,
-                    const uint8* src_a, int src_stride_a,
-                    uint8* dst_argb, int dst_stride_argb,
-                    int width, int height, int attenuate);
-
-// Convert I420 with Alpha to preattenuated ABGR.
-LIBYUV_API
-int I420AlphaToABGR(const uint8* src_y, int src_stride_y,
-                    const uint8* src_u, int src_stride_u,
-                    const uint8* src_v, int src_stride_v,
-                    const uint8* src_a, int src_stride_a,
-                    uint8* dst_abgr, int dst_stride_abgr,
-                    int width, int height, int attenuate);
-
-// Convert I400 (grey) to ARGB.  Reverse of ARGBToI400.
-LIBYUV_API
-int I400ToARGB(const uint8* src_y, int src_stride_y,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert J400 (jpeg grey) to ARGB.
-LIBYUV_API
-int J400ToARGB(const uint8* src_y, int src_stride_y,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Alias.
-#define YToARGB I400ToARGB
-
-// Convert NV12 to ARGB.
-LIBYUV_API
-int NV12ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_uv, int src_stride_uv,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert NV21 to ARGB.
-LIBYUV_API
-int NV21ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_vu, int src_stride_vu,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert M420 to ARGB.
-LIBYUV_API
-int M420ToARGB(const uint8* src_m420, int src_stride_m420,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert YUY2 to ARGB.
-LIBYUV_API
-int YUY2ToARGB(const uint8* src_yuy2, int src_stride_yuy2,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert UYVY to ARGB.
-LIBYUV_API
-int UYVYToARGB(const uint8* src_uyvy, int src_stride_uyvy,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert J420 to ARGB.
-LIBYUV_API
-int J420ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert J422 to ARGB.
-LIBYUV_API
-int J422ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert J420 to ABGR.
-LIBYUV_API
-int J420ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// Convert J422 to ABGR.
-LIBYUV_API
-int J422ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// Convert H420 to ARGB.
-LIBYUV_API
-int H420ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert H422 to ARGB.
-LIBYUV_API
-int H422ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert H420 to ABGR.
-LIBYUV_API
-int H420ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// Convert H422 to ABGR.
-LIBYUV_API
-int H422ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// BGRA little endian (argb in memory) to ARGB.
-LIBYUV_API
-int BGRAToARGB(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// ABGR little endian (rgba in memory) to ARGB.
-LIBYUV_API
-int ABGRToARGB(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// RGBA little endian (abgr in memory) to ARGB.
-LIBYUV_API
-int RGBAToARGB(const uint8* src_frame, int src_stride_frame,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Deprecated function name.
-#define BG24ToARGB RGB24ToARGB
-
-// RGB little endian (bgr in memory) to ARGB.
-LIBYUV_API
-int RGB24ToARGB(const uint8* src_frame, int src_stride_frame,
-                uint8* dst_argb, int dst_stride_argb,
-                int width, int height);
-
-// RGB big endian (rgb in memory) to ARGB.
-LIBYUV_API
-int RAWToARGB(const uint8* src_frame, int src_stride_frame,
-              uint8* dst_argb, int dst_stride_argb,
-              int width, int height);
-
-// RGB16 (RGBP fourcc) little endian to ARGB.
-LIBYUV_API
-int RGB565ToARGB(const uint8* src_frame, int src_stride_frame,
-                 uint8* dst_argb, int dst_stride_argb,
-                 int width, int height);
-
-// RGB15 (RGBO fourcc) little endian to ARGB.
-LIBYUV_API
-int ARGB1555ToARGB(const uint8* src_frame, int src_stride_frame,
-                   uint8* dst_argb, int dst_stride_argb,
-                   int width, int height);
-
-// RGB12 (R444 fourcc) little endian to ARGB.
-LIBYUV_API
-int ARGB4444ToARGB(const uint8* src_frame, int src_stride_frame,
-                   uint8* dst_argb, int dst_stride_argb,
-                   int width, int height);
-
-#ifdef HAVE_JPEG
-// src_width/height provided by capture
-// dst_width/height for clipping determine final size.
-LIBYUV_API
-int MJPGToARGB(const uint8* sample, size_t sample_size,
-               uint8* dst_argb, int dst_stride_argb,
-               int src_width, int src_height,
-               int dst_width, int dst_height);
-#endif
-
-// Convert camera sample to ARGB with cropping, rotation and vertical flip.
-// "src_size" is needed to parse MJPG.
-// "dst_stride_argb" number of bytes in a row of the dst_argb plane.
-//   Normally this would be the same as dst_width, with recommended alignment
-//   to 16 bytes for better efficiency.
-//   If rotation of 90 or 270 is used, stride is affected. The caller should
-//   allocate the I420 buffer according to rotation.
-// "dst_stride_u" number of bytes in a row of the dst_u plane.
-//   Normally this would be the same as (dst_width + 1) / 2, with
-//   recommended alignment to 16 bytes for better efficiency.
-//   If rotation of 90 or 270 is used, stride is affected.
-// "crop_x" and "crop_y" are starting position for cropping.
-//   To center, crop_x = (src_width - dst_width) / 2
-//              crop_y = (src_height - dst_height) / 2
-// "src_width" / "src_height" is size of src_frame in pixels.
-//   "src_height" can be negative indicating a vertically flipped image source.
-// "crop_width" / "crop_height" is the size to crop the src to.
-//    Must be less than or equal to src_width/src_height
-//    Cropping parameters are pre-rotation.
-// "rotation" can be 0, 90, 180 or 270.
-// "format" is a fourcc. ie 'I420', 'YUY2'
-// Returns 0 for successful; -1 for invalid parameter. Non-zero for failure.
-LIBYUV_API
-int ConvertToARGB(const uint8* src_frame, size_t src_size,
-                  uint8* dst_argb, int dst_stride_argb,
-                  int crop_x, int crop_y,
-                  int src_width, int src_height,
-                  int crop_width, int crop_height,
-                  enum RotationMode rotation,
-                  uint32 format);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_CONVERT_ARGB_H_

third_party/libyuv/x86_64/include/libyuv/convert_from.h

@@ -1,179 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_CONVERT_FROM_H_
-#define INCLUDE_LIBYUV_CONVERT_FROM_H_
-
-#include "libyuv/basic_types.h"
-#include "libyuv/rotate.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// See Also convert.h for conversions from formats to I420.
-
-// I420Copy in convert to I420ToI420.
-
-LIBYUV_API
-int I420ToI422(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-LIBYUV_API
-int I420ToI444(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-LIBYUV_API
-int I420ToI411(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Copy to I400. Source can be I420, I422, I444, I400, NV12 or NV21.
-LIBYUV_API
-int I400Copy(const uint8* src_y, int src_stride_y,
-             uint8* dst_y, int dst_stride_y,
-             int width, int height);
-
-LIBYUV_API
-int I420ToNV12(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_uv, int dst_stride_uv,
-               int width, int height);
-
-LIBYUV_API
-int I420ToNV21(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_vu, int dst_stride_vu,
-               int width, int height);
-
-LIBYUV_API
-int I420ToYUY2(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_frame, int dst_stride_frame,
-               int width, int height);
-
-LIBYUV_API
-int I420ToUYVY(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_frame, int dst_stride_frame,
-               int width, int height);
-
-LIBYUV_API
-int I420ToARGB(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-LIBYUV_API
-int I420ToBGRA(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-LIBYUV_API
-int I420ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-LIBYUV_API
-int I420ToRGBA(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_rgba, int dst_stride_rgba,
-               int width, int height);
-
-LIBYUV_API
-int I420ToRGB24(const uint8* src_y, int src_stride_y,
-                const uint8* src_u, int src_stride_u,
-                const uint8* src_v, int src_stride_v,
-                uint8* dst_frame, int dst_stride_frame,
-                int width, int height);
-
-LIBYUV_API
-int I420ToRAW(const uint8* src_y, int src_stride_y,
-              const uint8* src_u, int src_stride_u,
-              const uint8* src_v, int src_stride_v,
-              uint8* dst_frame, int dst_stride_frame,
-              int width, int height);
-
-LIBYUV_API
-int I420ToRGB565(const uint8* src_y, int src_stride_y,
-                 const uint8* src_u, int src_stride_u,
-                 const uint8* src_v, int src_stride_v,
-                 uint8* dst_frame, int dst_stride_frame,
-                 int width, int height);
-
-// Convert I420 To RGB565 with 4x4 dither matrix (16 bytes).
-// Values in dither matrix from 0 to 7 recommended.
-// The order of the dither matrix is first byte is upper left.
-
-LIBYUV_API
-int I420ToRGB565Dither(const uint8* src_y, int src_stride_y,
-                       const uint8* src_u, int src_stride_u,
-                       const uint8* src_v, int src_stride_v,
-                       uint8* dst_frame, int dst_stride_frame,
-                       const uint8* dither4x4, int width, int height);
-
-LIBYUV_API
-int I420ToARGB1555(const uint8* src_y, int src_stride_y,
-                   const uint8* src_u, int src_stride_u,
-                   const uint8* src_v, int src_stride_v,
-                   uint8* dst_frame, int dst_stride_frame,
-                   int width, int height);
-
-LIBYUV_API
-int I420ToARGB4444(const uint8* src_y, int src_stride_y,
-                   const uint8* src_u, int src_stride_u,
-                   const uint8* src_v, int src_stride_v,
-                   uint8* dst_frame, int dst_stride_frame,
-                   int width, int height);
-
-// Convert I420 to specified format.
-// "dst_sample_stride" is bytes in a row for the destination. Pass 0 if the
-//    buffer has contiguous rows. Can be negative. A multiple of 16 is optimal.
-LIBYUV_API
-int ConvertFromI420(const uint8* y, int y_stride,
-                    const uint8* u, int u_stride,
-                    const uint8* v, int v_stride,
-                    uint8* dst_sample, int dst_sample_stride,
-                    int width, int height,
-                    uint32 format);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_CONVERT_FROM_H_

third_party/libyuv/x86_64/include/libyuv/convert_from_argb.h

@@ -1,190 +0,0 @@
-/*
- *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_CONVERT_FROM_ARGB_H_
-#define INCLUDE_LIBYUV_CONVERT_FROM_ARGB_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Copy ARGB to ARGB.
-#define ARGBToARGB ARGBCopy
-LIBYUV_API
-int ARGBCopy(const uint8* src_argb, int src_stride_argb,
-             uint8* dst_argb, int dst_stride_argb,
-             int width, int height);
-
-// Convert ARGB To BGRA.
-LIBYUV_API
-int ARGBToBGRA(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_bgra, int dst_stride_bgra,
-               int width, int height);
-
-// Convert ARGB To ABGR.
-LIBYUV_API
-int ARGBToABGR(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// Convert ARGB To RGBA.
-LIBYUV_API
-int ARGBToRGBA(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_rgba, int dst_stride_rgba,
-               int width, int height);
-
-// Convert ARGB To RGB24.
-LIBYUV_API
-int ARGBToRGB24(const uint8* src_argb, int src_stride_argb,
-                uint8* dst_rgb24, int dst_stride_rgb24,
-                int width, int height);
-
-// Convert ARGB To RAW.
-LIBYUV_API
-int ARGBToRAW(const uint8* src_argb, int src_stride_argb,
-              uint8* dst_rgb, int dst_stride_rgb,
-              int width, int height);
-
-// Convert ARGB To RGB565.
-LIBYUV_API
-int ARGBToRGB565(const uint8* src_argb, int src_stride_argb,
-                 uint8* dst_rgb565, int dst_stride_rgb565,
-                 int width, int height);
-
-// Convert ARGB To RGB565 with 4x4 dither matrix (16 bytes).
-// Values in dither matrix from 0 to 7 recommended.
-// The order of the dither matrix is first byte is upper left.
-// TODO(fbarchard): Consider pointer to 2d array for dither4x4.
-// const uint8(*dither)[4][4];
-LIBYUV_API
-int ARGBToRGB565Dither(const uint8* src_argb, int src_stride_argb,
-                       uint8* dst_rgb565, int dst_stride_rgb565,
-                       const uint8* dither4x4, int width, int height);
-
-// Convert ARGB To ARGB1555.
-LIBYUV_API
-int ARGBToARGB1555(const uint8* src_argb, int src_stride_argb,
-                   uint8* dst_argb1555, int dst_stride_argb1555,
-                   int width, int height);
-
-// Convert ARGB To ARGB4444.
-LIBYUV_API
-int ARGBToARGB4444(const uint8* src_argb, int src_stride_argb,
-                   uint8* dst_argb4444, int dst_stride_argb4444,
-                   int width, int height);
-
-// Convert ARGB To I444.
-LIBYUV_API
-int ARGBToI444(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert ARGB To I422.
-LIBYUV_API
-int ARGBToI422(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert ARGB To I420. (also in convert.h)
-LIBYUV_API
-int ARGBToI420(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert ARGB to J420. (JPeg full range I420).
-LIBYUV_API
-int ARGBToJ420(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_yj, int dst_stride_yj,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert ARGB to J422.
-LIBYUV_API
-int ARGBToJ422(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_yj, int dst_stride_yj,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert ARGB To I411.
-LIBYUV_API
-int ARGBToI411(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert ARGB to J400. (JPeg full range).
-LIBYUV_API
-int ARGBToJ400(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_yj, int dst_stride_yj,
-               int width, int height);
-
-// Convert ARGB to I400.
-LIBYUV_API
-int ARGBToI400(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               int width, int height);
-
-// Convert ARGB to G. (Reverse of J400toARGB, which replicates G back to ARGB)
-LIBYUV_API
-int ARGBToG(const uint8* src_argb, int src_stride_argb,
-            uint8* dst_g, int dst_stride_g,
-            int width, int height);
-
-// Convert ARGB To NV12.
-LIBYUV_API
-int ARGBToNV12(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_uv, int dst_stride_uv,
-               int width, int height);
-
-// Convert ARGB To NV21.
-LIBYUV_API
-int ARGBToNV21(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_vu, int dst_stride_vu,
-               int width, int height);
-
-// Convert ARGB To NV21.
-LIBYUV_API
-int ARGBToNV21(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_vu, int dst_stride_vu,
-               int width, int height);
-
-// Convert ARGB To YUY2.
-LIBYUV_API
-int ARGBToYUY2(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_yuy2, int dst_stride_yuy2,
-               int width, int height);
-
-// Convert ARGB To UYVY.
-LIBYUV_API
-int ARGBToUYVY(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_uyvy, int dst_stride_uyvy,
-               int width, int height);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_CONVERT_FROM_ARGB_H_

third_party/libyuv/x86_64/include/libyuv/cpu_id.h

@@ -1,81 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_CPU_ID_H_
-#define INCLUDE_LIBYUV_CPU_ID_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Internal flag to indicate cpuid requires initialization.
-static const int kCpuInitialized = 0x1;
-
-// These flags are only valid on ARM processors.
-static const int kCpuHasARM = 0x2;
-static const int kCpuHasNEON = 0x4;
-// 0x8 reserved for future ARM flag.
-
-// These flags are only valid on x86 processors.
-static const int kCpuHasX86 = 0x10;
-static const int kCpuHasSSE2 = 0x20;
-static const int kCpuHasSSSE3 = 0x40;
-static const int kCpuHasSSE41 = 0x80;
-static const int kCpuHasSSE42 = 0x100;
-static const int kCpuHasAVX = 0x200;
-static const int kCpuHasAVX2 = 0x400;
-static const int kCpuHasERMS = 0x800;
-static const int kCpuHasFMA3 = 0x1000;
-static const int kCpuHasAVX3 = 0x2000;
-// 0x2000, 0x4000, 0x8000 reserved for future X86 flags.
-
-// These flags are only valid on MIPS processors.
-static const int kCpuHasMIPS = 0x10000;
-static const int kCpuHasDSPR2 = 0x20000;
-static const int kCpuHasMSA = 0x40000;
-
-// Internal function used to auto-init.
-LIBYUV_API
-int InitCpuFlags(void);
-
-// Internal function for parsing /proc/cpuinfo.
-LIBYUV_API
-int ArmCpuCaps(const char* cpuinfo_name);
-
-// Detect CPU has SSE2 etc.
-// Test_flag parameter should be one of kCpuHas constants above.
-// returns non-zero if instruction set is detected
-static __inline int TestCpuFlag(int test_flag) {
-  LIBYUV_API extern int cpu_info_;
-  return (!cpu_info_ ? InitCpuFlags() : cpu_info_) & test_flag;
-}
-
-// For testing, allow CPU flags to be disabled.
-// ie MaskCpuFlags(~kCpuHasSSSE3) to disable SSSE3.
-// MaskCpuFlags(-1) to enable all cpu specific optimizations.
-// MaskCpuFlags(1) to disable all cpu specific optimizations.
-LIBYUV_API
-void MaskCpuFlags(int enable_flags);
-
-// Low level cpuid for X86. Returns zeros on other CPUs.
-// eax is the info type that you want.
-// ecx is typically the cpu number, and should normally be zero.
-LIBYUV_API
-void CpuId(uint32 eax, uint32 ecx, uint32* cpu_info);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_CPU_ID_H_

third_party/libyuv/x86_64/include/libyuv/macros_msa.h

@@ -1,76 +0,0 @@
-/*
- *  Copyright 2016 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_MACROS_MSA_H_
-#define INCLUDE_LIBYUV_MACROS_MSA_H_
-
-#if !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa)
-#include <stdint.h>
-#include <msa.h>
-
-#define LD_B(RTYPE, psrc) *((RTYPE*)(psrc))   /* NOLINT */
-#define LD_UB(...) LD_B(v16u8, __VA_ARGS__)
-
-#define ST_B(RTYPE, in, pdst) *((RTYPE*)(pdst)) = (in)  /* NOLINT */
-#define ST_UB(...) ST_B(v16u8, __VA_ARGS__)
-
-/* Description : Load two vectors with 16 'byte' sized elements
-   Arguments   : Inputs  - psrc, stride
-                 Outputs - out0, out1
-                 Return Type - as per RTYPE
-   Details     : Load 16 byte elements in 'out0' from (psrc)
-                 Load 16 byte elements in 'out1' from (psrc + stride)
-*/
-#define LD_B2(RTYPE, psrc, stride, out0, out1) {  \
-  out0 = LD_B(RTYPE, (psrc));                     \
-  out1 = LD_B(RTYPE, (psrc) + stride);            \
-}
-#define LD_UB2(...) LD_B2(v16u8, __VA_ARGS__)
-
-#define LD_B4(RTYPE, psrc, stride, out0, out1, out2, out3) {  \
-  LD_B2(RTYPE, (psrc), stride, out0, out1);                   \
-  LD_B2(RTYPE, (psrc) + 2 * stride , stride, out2, out3);     \
-}
-#define LD_UB4(...) LD_B4(v16u8, __VA_ARGS__)
-
-/* Description : Store two vectors with stride each having 16 'byte' sized
-                 elements
-   Arguments   : Inputs - in0, in1, pdst, stride
-   Details     : Store 16 byte elements from 'in0' to (pdst)
-                 Store 16 byte elements from 'in1' to (pdst + stride)
-*/
-#define ST_B2(RTYPE, in0, in1, pdst, stride) {  \
-  ST_B(RTYPE, in0, (pdst));                     \
-  ST_B(RTYPE, in1, (pdst) + stride);            \
-}
-#define ST_UB2(...) ST_B2(v16u8, __VA_ARGS__)
-#
-#define ST_B4(RTYPE, in0, in1, in2, in3, pdst, stride) {  \
-  ST_B2(RTYPE, in0, in1, (pdst), stride);                 \
-  ST_B2(RTYPE, in2, in3, (pdst) + 2 * stride, stride);    \
-}
-#define ST_UB4(...) ST_B4(v16u8, __VA_ARGS__)
-#
-/* Description : Shuffle byte vector elements as per mask vector
-   Arguments   : Inputs  - in0, in1, in2, in3, mask0, mask1
-                 Outputs - out0, out1
-                 Return Type - as per RTYPE
-   Details     : Byte elements from 'in0' & 'in1' are copied selectively to
-                 'out0' as per control vector 'mask0'
-*/
-#define VSHF_B2(RTYPE, in0, in1, in2, in3, mask0, mask1, out0, out1) {   \
-  out0 = (RTYPE) __msa_vshf_b((v16i8) mask0, (v16i8) in1, (v16i8) in0);  \
-  out1 = (RTYPE) __msa_vshf_b((v16i8) mask1, (v16i8) in3, (v16i8) in2);  \
-}
-#define VSHF_B2_UB(...) VSHF_B2(v16u8, __VA_ARGS__)
-
-#endif  /* !defined(LIBYUV_DISABLE_MSA) && defined(__mips_msa) */
-
-#endif  // INCLUDE_LIBYUV_MACROS_MSA_H_

third_party/libyuv/x86_64/include/libyuv/mjpeg_decoder.h

@@ -1,192 +0,0 @@
-/*
- *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_MJPEG_DECODER_H_
-#define INCLUDE_LIBYUV_MJPEG_DECODER_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-// NOTE: For a simplified public API use convert.h MJPGToI420().
-
-struct jpeg_common_struct;
-struct jpeg_decompress_struct;
-struct jpeg_source_mgr;
-
-namespace libyuv {
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-LIBYUV_BOOL ValidateJpeg(const uint8* sample, size_t sample_size);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-static const uint32 kUnknownDataSize = 0xFFFFFFFF;
-
-enum JpegSubsamplingType {
-  kJpegYuv420,
-  kJpegYuv422,
-  kJpegYuv411,
-  kJpegYuv444,
-  kJpegYuv400,
-  kJpegUnknown
-};
-
-struct Buffer {
-  const uint8* data;
-  int len;
-};
-
-struct BufferVector {
-  Buffer* buffers;
-  int len;
-  int pos;
-};
-
-struct SetJmpErrorMgr;
-
-// MJPEG ("Motion JPEG") is a pseudo-standard video codec where the frames are
-// simply independent JPEG images with a fixed huffman table (which is omitted).
-// It is rarely used in video transmission, but is common as a camera capture
-// format, especially in Logitech devices. This class implements a decoder for
-// MJPEG frames.
-//
-// See http://tools.ietf.org/html/rfc2435
-class LIBYUV_API MJpegDecoder {
- public:
-  typedef void (*CallbackFunction)(void* opaque,
-                                   const uint8* const* data,
-                                   const int* strides,
-                                   int rows);
-
-  static const int kColorSpaceUnknown;
-  static const int kColorSpaceGrayscale;
-  static const int kColorSpaceRgb;
-  static const int kColorSpaceYCbCr;
-  static const int kColorSpaceCMYK;
-  static const int kColorSpaceYCCK;
-
-  MJpegDecoder();
-  ~MJpegDecoder();
-
-  // Loads a new frame, reads its headers, and determines the uncompressed
-  // image format.
-  // Returns LIBYUV_TRUE if image looks valid and format is supported.
-  // If return value is LIBYUV_TRUE, then the values for all the following
-  // getters are populated.
-  // src_len is the size of the compressed mjpeg frame in bytes.
-  LIBYUV_BOOL LoadFrame(const uint8* src, size_t src_len);
-
-  // Returns width of the last loaded frame in pixels.
-  int GetWidth();
-
-  // Returns height of the last loaded frame in pixels.
-  int GetHeight();
-
-  // Returns format of the last loaded frame. The return value is one of the
-  // kColorSpace* constants.
-  int GetColorSpace();
-
-  // Number of color components in the color space.
-  int GetNumComponents();
-
-  // Sample factors of the n-th component.
-  int GetHorizSampFactor(int component);
-
-  int GetVertSampFactor(int component);
-
-  int GetHorizSubSampFactor(int component);
-
-  int GetVertSubSampFactor(int component);
-
-  // Public for testability.
-  int GetImageScanlinesPerImcuRow();
-
-  // Public for testability.
-  int GetComponentScanlinesPerImcuRow(int component);
-
-  // Width of a component in bytes.
-  int GetComponentWidth(int component);
-
-  // Height of a component.
-  int GetComponentHeight(int component);
-
-  // Width of a component in bytes with padding for DCTSIZE. Public for testing.
-  int GetComponentStride(int component);
-
-  // Size of a component in bytes.
-  int GetComponentSize(int component);
-
-  // Call this after LoadFrame() if you decide you don't want to decode it
-  // after all.
-  LIBYUV_BOOL UnloadFrame();
-
-  // Decodes the entire image into a one-buffer-per-color-component format.
-  // dst_width must match exactly. dst_height must be <= to image height; if
-  // less, the image is cropped. "planes" must have size equal to at least
-  // GetNumComponents() and they must point to non-overlapping buffers of size
-  // at least GetComponentSize(i). The pointers in planes are incremented
-  // to point to after the end of the written data.
-  // TODO(fbarchard): Add dst_x, dst_y to allow specific rect to be decoded.
-  LIBYUV_BOOL DecodeToBuffers(uint8** planes, int dst_width, int dst_height);
-
-  // Decodes the entire image and passes the data via repeated calls to a
-  // callback function. Each call will get the data for a whole number of
-  // image scanlines.
-  // TODO(fbarchard): Add dst_x, dst_y to allow specific rect to be decoded.
-  LIBYUV_BOOL DecodeToCallback(CallbackFunction fn, void* opaque,
-                        int dst_width, int dst_height);
-
-  // The helper function which recognizes the jpeg sub-sampling type.
-  static JpegSubsamplingType JpegSubsamplingTypeHelper(
-     int* subsample_x, int* subsample_y, int number_of_components);
-
- private:
-  void AllocOutputBuffers(int num_outbufs);
-  void DestroyOutputBuffers();
-
-  LIBYUV_BOOL StartDecode();
-  LIBYUV_BOOL FinishDecode();
-
-  void SetScanlinePointers(uint8** data);
-  LIBYUV_BOOL DecodeImcuRow();
-
-  int GetComponentScanlinePadding(int component);
-
-  // A buffer holding the input data for a frame.
-  Buffer buf_;
-  BufferVector buf_vec_;
-
-  jpeg_decompress_struct* decompress_struct_;
-  jpeg_source_mgr* source_mgr_;
-  SetJmpErrorMgr* error_mgr_;
-
-  // LIBYUV_TRUE iff at least one component has scanline padding. (i.e.,
-  // GetComponentScanlinePadding() != 0.)
-  LIBYUV_BOOL has_scanline_padding_;
-
-  // Temporaries used to point to scanline outputs.
-  int num_outbufs_;  // Outermost size of all arrays below.
-  uint8*** scanlines_;
-  int* scanlines_sizes_;
-  // Temporary buffer used for decoding when we can't decode directly to the
-  // output buffers. Large enough for just one iMCU row.
-  uint8** databuf_;
-  int* databuf_strides_;
-};
-
-}  // namespace libyuv
-
-#endif  //  __cplusplus
-#endif  // INCLUDE_LIBYUV_MJPEG_DECODER_H_

third_party/libyuv/x86_64/include/libyuv/planar_functions.h

@@ -1,529 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_PLANAR_FUNCTIONS_H_
-#define INCLUDE_LIBYUV_PLANAR_FUNCTIONS_H_
-
-#include "libyuv/basic_types.h"
-
-// TODO(fbarchard): Remove the following headers includes.
-#include "libyuv/convert.h"
-#include "libyuv/convert_argb.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Copy a plane of data.
-LIBYUV_API
-void CopyPlane(const uint8* src_y, int src_stride_y,
-               uint8* dst_y, int dst_stride_y,
-               int width, int height);
-
-LIBYUV_API
-void CopyPlane_16(const uint16* src_y, int src_stride_y,
-                  uint16* dst_y, int dst_stride_y,
-                  int width, int height);
-
-// Set a plane of data to a 32 bit value.
-LIBYUV_API
-void SetPlane(uint8* dst_y, int dst_stride_y,
-              int width, int height,
-              uint32 value);
-
-// Split interleaved UV plane into separate U and V planes.
-LIBYUV_API
-void SplitUVPlane(const uint8* src_uv, int src_stride_uv,
-                  uint8* dst_u, int dst_stride_u,
-                  uint8* dst_v, int dst_stride_v,
-                  int width, int height);
-
-// Merge separate U and V planes into one interleaved UV plane.
-LIBYUV_API
-void MergeUVPlane(const uint8* src_u, int src_stride_u,
-                  const uint8* src_v, int src_stride_v,
-                  uint8* dst_uv, int dst_stride_uv,
-                  int width, int height);
-
-// Copy I400.  Supports inverting.
-LIBYUV_API
-int I400ToI400(const uint8* src_y, int src_stride_y,
-               uint8* dst_y, int dst_stride_y,
-               int width, int height);
-
-#define J400ToJ400 I400ToI400
-
-// Copy I422 to I422.
-#define I422ToI422 I422Copy
-LIBYUV_API
-int I422Copy(const uint8* src_y, int src_stride_y,
-             const uint8* src_u, int src_stride_u,
-             const uint8* src_v, int src_stride_v,
-             uint8* dst_y, int dst_stride_y,
-             uint8* dst_u, int dst_stride_u,
-             uint8* dst_v, int dst_stride_v,
-             int width, int height);
-
-// Copy I444 to I444.
-#define I444ToI444 I444Copy
-LIBYUV_API
-int I444Copy(const uint8* src_y, int src_stride_y,
-             const uint8* src_u, int src_stride_u,
-             const uint8* src_v, int src_stride_v,
-             uint8* dst_y, int dst_stride_y,
-             uint8* dst_u, int dst_stride_u,
-             uint8* dst_v, int dst_stride_v,
-             int width, int height);
-
-// Convert YUY2 to I422.
-LIBYUV_API
-int YUY2ToI422(const uint8* src_yuy2, int src_stride_yuy2,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Convert UYVY to I422.
-LIBYUV_API
-int UYVYToI422(const uint8* src_uyvy, int src_stride_uyvy,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-LIBYUV_API
-int YUY2ToNV12(const uint8* src_yuy2, int src_stride_yuy2,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_uv, int dst_stride_uv,
-               int width, int height);
-
-LIBYUV_API
-int UYVYToNV12(const uint8* src_uyvy, int src_stride_uyvy,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_uv, int dst_stride_uv,
-               int width, int height);
-
-// Convert I420 to I400. (calls CopyPlane ignoring u/v).
-LIBYUV_API
-int I420ToI400(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               int width, int height);
-
-// Alias
-#define J420ToJ400 I420ToI400
-#define I420ToI420Mirror I420Mirror
-
-// I420 mirror.
-LIBYUV_API
-int I420Mirror(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int width, int height);
-
-// Alias
-#define I400ToI400Mirror I400Mirror
-
-// I400 mirror.  A single plane is mirrored horizontally.
-// Pass negative height to achieve 180 degree rotation.
-LIBYUV_API
-int I400Mirror(const uint8* src_y, int src_stride_y,
-               uint8* dst_y, int dst_stride_y,
-               int width, int height);
-
-// Alias
-#define ARGBToARGBMirror ARGBMirror
-
-// ARGB mirror.
-LIBYUV_API
-int ARGBMirror(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Convert NV12 to RGB565.
-LIBYUV_API
-int NV12ToRGB565(const uint8* src_y, int src_stride_y,
-                 const uint8* src_uv, int src_stride_uv,
-                 uint8* dst_rgb565, int dst_stride_rgb565,
-                 int width, int height);
-
-// I422ToARGB is in convert_argb.h
-// Convert I422 to BGRA.
-LIBYUV_API
-int I422ToBGRA(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_bgra, int dst_stride_bgra,
-               int width, int height);
-
-// Convert I422 to ABGR.
-LIBYUV_API
-int I422ToABGR(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_abgr, int dst_stride_abgr,
-               int width, int height);
-
-// Convert I422 to RGBA.
-LIBYUV_API
-int I422ToRGBA(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_rgba, int dst_stride_rgba,
-               int width, int height);
-
-// Alias
-#define RGB24ToRAW RAWToRGB24
-
-LIBYUV_API
-int RAWToRGB24(const uint8* src_raw, int src_stride_raw,
-               uint8* dst_rgb24, int dst_stride_rgb24,
-               int width, int height);
-
-// Draw a rectangle into I420.
-LIBYUV_API
-int I420Rect(uint8* dst_y, int dst_stride_y,
-             uint8* dst_u, int dst_stride_u,
-             uint8* dst_v, int dst_stride_v,
-             int x, int y, int width, int height,
-             int value_y, int value_u, int value_v);
-
-// Draw a rectangle into ARGB.
-LIBYUV_API
-int ARGBRect(uint8* dst_argb, int dst_stride_argb,
-             int x, int y, int width, int height, uint32 value);
-
-// Convert ARGB to gray scale ARGB.
-LIBYUV_API
-int ARGBGrayTo(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_argb, int dst_stride_argb,
-               int width, int height);
-
-// Make a rectangle of ARGB gray scale.
-LIBYUV_API
-int ARGBGray(uint8* dst_argb, int dst_stride_argb,
-             int x, int y, int width, int height);
-
-// Make a rectangle of ARGB Sepia tone.
-LIBYUV_API
-int ARGBSepia(uint8* dst_argb, int dst_stride_argb,
-              int x, int y, int width, int height);
-
-// Apply a matrix rotation to each ARGB pixel.
-// matrix_argb is 4 signed ARGB values. -128 to 127 representing -2 to 2.
-// The first 4 coefficients apply to B, G, R, A and produce B of the output.
-// The next 4 coefficients apply to B, G, R, A and produce G of the output.
-// The next 4 coefficients apply to B, G, R, A and produce R of the output.
-// The last 4 coefficients apply to B, G, R, A and produce A of the output.
-LIBYUV_API
-int ARGBColorMatrix(const uint8* src_argb, int src_stride_argb,
-                    uint8* dst_argb, int dst_stride_argb,
-                    const int8* matrix_argb,
-                    int width, int height);
-
-// Deprecated. Use ARGBColorMatrix instead.
-// Apply a matrix rotation to each ARGB pixel.
-// matrix_argb is 3 signed ARGB values. -128 to 127 representing -1 to 1.
-// The first 4 coefficients apply to B, G, R, A and produce B of the output.
-// The next 4 coefficients apply to B, G, R, A and produce G of the output.
-// The last 4 coefficients apply to B, G, R, A and produce R of the output.
-LIBYUV_API
-int RGBColorMatrix(uint8* dst_argb, int dst_stride_argb,
-                   const int8* matrix_rgb,
-                   int x, int y, int width, int height);
-
-// Apply a color table each ARGB pixel.
-// Table contains 256 ARGB values.
-LIBYUV_API
-int ARGBColorTable(uint8* dst_argb, int dst_stride_argb,
-                   const uint8* table_argb,
-                   int x, int y, int width, int height);
-
-// Apply a color table each ARGB pixel but preserve destination alpha.
-// Table contains 256 ARGB values.
-LIBYUV_API
-int RGBColorTable(uint8* dst_argb, int dst_stride_argb,
-                  const uint8* table_argb,
-                  int x, int y, int width, int height);
-
-// Apply a luma/color table each ARGB pixel but preserve destination alpha.
-// Table contains 32768 values indexed by [Y][C] where 7 it 7 bit luma from
-// RGB (YJ style) and C is an 8 bit color component (R, G or B).
-LIBYUV_API
-int ARGBLumaColorTable(const uint8* src_argb, int src_stride_argb,
-                       uint8* dst_argb, int dst_stride_argb,
-                       const uint8* luma_rgb_table,
-                       int width, int height);
-
-// Apply a 3 term polynomial to ARGB values.
-// poly points to a 4x4 matrix.  The first row is constants.  The 2nd row is
-// coefficients for b, g, r and a.  The 3rd row is coefficients for b squared,
-// g squared, r squared and a squared.  The 4rd row is coefficients for b to
-// the 3, g to the 3, r to the 3 and a to the 3.  The values are summed and
-// result clamped to 0 to 255.
-// A polynomial approximation can be dirived using software such as 'R'.
-
-LIBYUV_API
-int ARGBPolynomial(const uint8* src_argb, int src_stride_argb,
-                   uint8* dst_argb, int dst_stride_argb,
-                   const float* poly,
-                   int width, int height);
-
-// Convert plane of 16 bit shorts to half floats.
-// Source values are multiplied by scale before storing as half float.
-LIBYUV_API
-int HalfFloatPlane(const uint16* src_y, int src_stride_y,
-                   uint16* dst_y, int dst_stride_y,
-                   float scale,
-                   int width, int height);
-
-// Quantize a rectangle of ARGB. Alpha unaffected.
-// scale is a 16 bit fractional fixed point scaler between 0 and 65535.
-// interval_size should be a value between 1 and 255.
-// interval_offset should be a value between 0 and 255.
-LIBYUV_API
-int ARGBQuantize(uint8* dst_argb, int dst_stride_argb,
-                 int scale, int interval_size, int interval_offset,
-                 int x, int y, int width, int height);
-
-// Copy ARGB to ARGB.
-LIBYUV_API
-int ARGBCopy(const uint8* src_argb, int src_stride_argb,
-             uint8* dst_argb, int dst_stride_argb,
-             int width, int height);
-
-// Copy Alpha channel of ARGB to alpha of ARGB.
-LIBYUV_API
-int ARGBCopyAlpha(const uint8* src_argb, int src_stride_argb,
-                  uint8* dst_argb, int dst_stride_argb,
-                  int width, int height);
-
-// Extract the alpha channel from ARGB.
-LIBYUV_API
-int ARGBExtractAlpha(const uint8* src_argb, int src_stride_argb,
-                     uint8* dst_a, int dst_stride_a,
-                     int width, int height);
-
-// Copy Y channel to Alpha of ARGB.
-LIBYUV_API
-int ARGBCopyYToAlpha(const uint8* src_y, int src_stride_y,
-                     uint8* dst_argb, int dst_stride_argb,
-                     int width, int height);
-
-typedef void (*ARGBBlendRow)(const uint8* src_argb0, const uint8* src_argb1,
-                             uint8* dst_argb, int width);
-
-// Get function to Alpha Blend ARGB pixels and store to destination.
-LIBYUV_API
-ARGBBlendRow GetARGBBlend();
-
-// Alpha Blend ARGB images and store to destination.
-// Source is pre-multiplied by alpha using ARGBAttenuate.
-// Alpha of destination is set to 255.
-LIBYUV_API
-int ARGBBlend(const uint8* src_argb0, int src_stride_argb0,
-              const uint8* src_argb1, int src_stride_argb1,
-              uint8* dst_argb, int dst_stride_argb,
-              int width, int height);
-
-// Alpha Blend plane and store to destination.
-// Source is not pre-multiplied by alpha.
-LIBYUV_API
-int BlendPlane(const uint8* src_y0, int src_stride_y0,
-               const uint8* src_y1, int src_stride_y1,
-               const uint8* alpha, int alpha_stride,
-               uint8* dst_y, int dst_stride_y,
-               int width, int height);
-
-// Alpha Blend YUV images and store to destination.
-// Source is not pre-multiplied by alpha.
-// Alpha is full width x height and subsampled to half size to apply to UV.
-LIBYUV_API
-int I420Blend(const uint8* src_y0, int src_stride_y0,
-              const uint8* src_u0, int src_stride_u0,
-              const uint8* src_v0, int src_stride_v0,
-              const uint8* src_y1, int src_stride_y1,
-              const uint8* src_u1, int src_stride_u1,
-              const uint8* src_v1, int src_stride_v1,
-              const uint8* alpha, int alpha_stride,
-              uint8* dst_y, int dst_stride_y,
-              uint8* dst_u, int dst_stride_u,
-              uint8* dst_v, int dst_stride_v,
-              int width, int height);
-
-// Multiply ARGB image by ARGB image. Shifted down by 8. Saturates to 255.
-LIBYUV_API
-int ARGBMultiply(const uint8* src_argb0, int src_stride_argb0,
-                 const uint8* src_argb1, int src_stride_argb1,
-                 uint8* dst_argb, int dst_stride_argb,
-                 int width, int height);
-
-// Add ARGB image with ARGB image. Saturates to 255.
-LIBYUV_API
-int ARGBAdd(const uint8* src_argb0, int src_stride_argb0,
-            const uint8* src_argb1, int src_stride_argb1,
-            uint8* dst_argb, int dst_stride_argb,
-            int width, int height);
-
-// Subtract ARGB image (argb1) from ARGB image (argb0). Saturates to 0.
-LIBYUV_API
-int ARGBSubtract(const uint8* src_argb0, int src_stride_argb0,
-                 const uint8* src_argb1, int src_stride_argb1,
-                 uint8* dst_argb, int dst_stride_argb,
-                 int width, int height);
-
-// Convert I422 to YUY2.
-LIBYUV_API
-int I422ToYUY2(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_frame, int dst_stride_frame,
-               int width, int height);
-
-// Convert I422 to UYVY.
-LIBYUV_API
-int I422ToUYVY(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_frame, int dst_stride_frame,
-               int width, int height);
-
-// Convert unattentuated ARGB to preattenuated ARGB.
-LIBYUV_API
-int ARGBAttenuate(const uint8* src_argb, int src_stride_argb,
-                  uint8* dst_argb, int dst_stride_argb,
-                  int width, int height);
-
-// Convert preattentuated ARGB to unattenuated ARGB.
-LIBYUV_API
-int ARGBUnattenuate(const uint8* src_argb, int src_stride_argb,
-                    uint8* dst_argb, int dst_stride_argb,
-                    int width, int height);
-
-// Internal function - do not call directly.
-// Computes table of cumulative sum for image where the value is the sum
-// of all values above and to the left of the entry. Used by ARGBBlur.
-LIBYUV_API
-int ARGBComputeCumulativeSum(const uint8* src_argb, int src_stride_argb,
-                             int32* dst_cumsum, int dst_stride32_cumsum,
-                             int width, int height);
-
-// Blur ARGB image.
-// dst_cumsum table of width * (height + 1) * 16 bytes aligned to
-//   16 byte boundary.
-// dst_stride32_cumsum is number of ints in a row (width * 4).
-// radius is number of pixels around the center.  e.g. 1 = 3x3. 2=5x5.
-// Blur is optimized for radius of 5 (11x11) or less.
-LIBYUV_API
-int ARGBBlur(const uint8* src_argb, int src_stride_argb,
-             uint8* dst_argb, int dst_stride_argb,
-             int32* dst_cumsum, int dst_stride32_cumsum,
-             int width, int height, int radius);
-
-// Multiply ARGB image by ARGB value.
-LIBYUV_API
-int ARGBShade(const uint8* src_argb, int src_stride_argb,
-              uint8* dst_argb, int dst_stride_argb,
-              int width, int height, uint32 value);
-
-// Interpolate between two images using specified amount of interpolation
-// (0 to 255) and store to destination.
-// 'interpolation' is specified as 8 bit fraction where 0 means 100% src0
-// and 255 means 1% src0 and 99% src1.
-LIBYUV_API
-int InterpolatePlane(const uint8* src0, int src_stride0,
-                     const uint8* src1, int src_stride1,
-                     uint8* dst, int dst_stride,
-                     int width, int height, int interpolation);
-
-// Interpolate between two ARGB images using specified amount of interpolation
-// Internally calls InterpolatePlane with width * 4 (bpp).
-LIBYUV_API
-int ARGBInterpolate(const uint8* src_argb0, int src_stride_argb0,
-                    const uint8* src_argb1, int src_stride_argb1,
-                    uint8* dst_argb, int dst_stride_argb,
-                    int width, int height, int interpolation);
-
-// Interpolate between two YUV images using specified amount of interpolation
-// Internally calls InterpolatePlane on each plane where the U and V planes
-// are half width and half height.
-LIBYUV_API
-int I420Interpolate(const uint8* src0_y, int src0_stride_y,
-                    const uint8* src0_u, int src0_stride_u,
-                    const uint8* src0_v, int src0_stride_v,
-                    const uint8* src1_y, int src1_stride_y,
-                    const uint8* src1_u, int src1_stride_u,
-                    const uint8* src1_v, int src1_stride_v,
-                    uint8* dst_y, int dst_stride_y,
-                    uint8* dst_u, int dst_stride_u,
-                    uint8* dst_v, int dst_stride_v,
-                    int width, int height, int interpolation);
-
-#if defined(__pnacl__) || defined(__CLR_VER) || \
-    (defined(__i386__) && !defined(__SSE2__))
-#define LIBYUV_DISABLE_X86
-#endif
-// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#define LIBYUV_DISABLE_X86
-#endif
-#endif
-// The following are available on all x86 platforms:
-#if !defined(LIBYUV_DISABLE_X86) && \
-    (defined(_M_IX86) || defined(__x86_64__) || defined(__i386__))
-#define HAS_ARGBAFFINEROW_SSE2
-#endif
-
-// Row function for copying pixels from a source with a slope to a row
-// of destination. Useful for scaling, rotation, mirror, texture mapping.
-LIBYUV_API
-void ARGBAffineRow_C(const uint8* src_argb, int src_argb_stride,
-                     uint8* dst_argb, const float* uv_dudv, int width);
-LIBYUV_API
-void ARGBAffineRow_SSE2(const uint8* src_argb, int src_argb_stride,
-                        uint8* dst_argb, const float* uv_dudv, int width);
-
-// Shuffle ARGB channel order.  e.g. BGRA to ARGB.
-// shuffler is 16 bytes and must be aligned.
-LIBYUV_API
-int ARGBShuffle(const uint8* src_bgra, int src_stride_bgra,
-                uint8* dst_argb, int dst_stride_argb,
-                const uint8* shuffler, int width, int height);
-
-// Sobel ARGB effect with planar output.
-LIBYUV_API
-int ARGBSobelToPlane(const uint8* src_argb, int src_stride_argb,
-                     uint8* dst_y, int dst_stride_y,
-                     int width, int height);
-
-// Sobel ARGB effect.
-LIBYUV_API
-int ARGBSobel(const uint8* src_argb, int src_stride_argb,
-              uint8* dst_argb, int dst_stride_argb,
-              int width, int height);
-
-// Sobel ARGB effect w/ Sobel X, Sobel, Sobel Y in ARGB.
-LIBYUV_API
-int ARGBSobelXY(const uint8* src_argb, int src_stride_argb,
-                uint8* dst_argb, int dst_stride_argb,
-                int width, int height);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_PLANAR_FUNCTIONS_H_

third_party/libyuv/x86_64/include/libyuv/rotate.h

@@ -1,117 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_ROTATE_H_
-#define INCLUDE_LIBYUV_ROTATE_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Supported rotation.
-typedef enum RotationMode {
-  kRotate0 = 0,  // No rotation.
-  kRotate90 = 90,  // Rotate 90 degrees clockwise.
-  kRotate180 = 180,  // Rotate 180 degrees.
-  kRotate270 = 270,  // Rotate 270 degrees clockwise.
-
-  // Deprecated.
-  kRotateNone = 0,
-  kRotateClockwise = 90,
-  kRotateCounterClockwise = 270,
-} RotationModeEnum;
-
-// Rotate I420 frame.
-LIBYUV_API
-int I420Rotate(const uint8* src_y, int src_stride_y,
-               const uint8* src_u, int src_stride_u,
-               const uint8* src_v, int src_stride_v,
-               uint8* dst_y, int dst_stride_y,
-               uint8* dst_u, int dst_stride_u,
-               uint8* dst_v, int dst_stride_v,
-               int src_width, int src_height, enum RotationMode mode);
-
-// Rotate NV12 input and store in I420.
-LIBYUV_API
-int NV12ToI420Rotate(const uint8* src_y, int src_stride_y,
-                     const uint8* src_uv, int src_stride_uv,
-                     uint8* dst_y, int dst_stride_y,
-                     uint8* dst_u, int dst_stride_u,
-                     uint8* dst_v, int dst_stride_v,
-                     int src_width, int src_height, enum RotationMode mode);
-
-// Rotate a plane by 0, 90, 180, or 270.
-LIBYUV_API
-int RotatePlane(const uint8* src, int src_stride,
-                uint8* dst, int dst_stride,
-                int src_width, int src_height, enum RotationMode mode);
-
-// Rotate planes by 90, 180, 270. Deprecated.
-LIBYUV_API
-void RotatePlane90(const uint8* src, int src_stride,
-                   uint8* dst, int dst_stride,
-                   int width, int height);
-
-LIBYUV_API
-void RotatePlane180(const uint8* src, int src_stride,
-                    uint8* dst, int dst_stride,
-                    int width, int height);
-
-LIBYUV_API
-void RotatePlane270(const uint8* src, int src_stride,
-                    uint8* dst, int dst_stride,
-                    int width, int height);
-
-LIBYUV_API
-void RotateUV90(const uint8* src, int src_stride,
-                uint8* dst_a, int dst_stride_a,
-                uint8* dst_b, int dst_stride_b,
-                int width, int height);
-
-// Rotations for when U and V are interleaved.
-// These functions take one input pointer and
-// split the data into two buffers while
-// rotating them. Deprecated.
-LIBYUV_API
-void RotateUV180(const uint8* src, int src_stride,
-                 uint8* dst_a, int dst_stride_a,
-                 uint8* dst_b, int dst_stride_b,
-                 int width, int height);
-
-LIBYUV_API
-void RotateUV270(const uint8* src, int src_stride,
-                 uint8* dst_a, int dst_stride_a,
-                 uint8* dst_b, int dst_stride_b,
-                 int width, int height);
-
-// The 90 and 270 functions are based on transposes.
-// Doing a transpose with reversing the read/write
-// order will result in a rotation by +- 90 degrees.
-// Deprecated.
-LIBYUV_API
-void TransposePlane(const uint8* src, int src_stride,
-                    uint8* dst, int dst_stride,
-                    int width, int height);
-
-LIBYUV_API
-void TransposeUV(const uint8* src, int src_stride,
-                 uint8* dst_a, int dst_stride_a,
-                 uint8* dst_b, int dst_stride_b,
-                 int width, int height);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_ROTATE_H_

third_party/libyuv/x86_64/include/libyuv/rotate_argb.h

@@ -1,33 +0,0 @@
-/*
- *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_ROTATE_ARGB_H_
-#define INCLUDE_LIBYUV_ROTATE_ARGB_H_
-
-#include "libyuv/basic_types.h"
-#include "libyuv/rotate.h"  // For RotationMode.
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Rotate ARGB frame
-LIBYUV_API
-int ARGBRotate(const uint8* src_argb, int src_stride_argb,
-               uint8* dst_argb, int dst_stride_argb,
-               int src_width, int src_height, enum RotationMode mode);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_ROTATE_ARGB_H_

third_party/libyuv/x86_64/include/libyuv/rotate_row.h

@@ -1,121 +0,0 @@
-/*
- *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_ROTATE_ROW_H_
-#define INCLUDE_LIBYUV_ROTATE_ROW_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-#if defined(__pnacl__) || defined(__CLR_VER) || \
-    (defined(__i386__) && !defined(__SSE2__))
-#define LIBYUV_DISABLE_X86
-#endif
-// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#define LIBYUV_DISABLE_X86
-#endif
-#endif
-// The following are available for Visual C and clangcl 32 bit:
-#if !defined(LIBYUV_DISABLE_X86) && defined(_M_IX86)
-#define HAS_TRANSPOSEWX8_SSSE3
-#define HAS_TRANSPOSEUVWX8_SSE2
-#endif
-
-// The following are available for GCC 32 or 64 bit but not NaCL for 64 bit:
-#if !defined(LIBYUV_DISABLE_X86) && \
-    (defined(__i386__) || (defined(__x86_64__) && !defined(__native_client__)))
-#define HAS_TRANSPOSEWX8_SSSE3
-#endif
-
-// The following are available for 64 bit GCC but not NaCL:
-#if !defined(LIBYUV_DISABLE_X86) && !defined(__native_client__) && \
-    defined(__x86_64__)
-#define HAS_TRANSPOSEWX8_FAST_SSSE3
-#define HAS_TRANSPOSEUVWX8_SSE2
-#endif
-
-#if !defined(LIBYUV_DISABLE_NEON) && !defined(__native_client__) && \
-    (defined(__ARM_NEON__) || defined(LIBYUV_NEON) || defined(__aarch64__))
-#define HAS_TRANSPOSEWX8_NEON
-#define HAS_TRANSPOSEUVWX8_NEON
-#endif
-
-#if !defined(LIBYUV_DISABLE_MIPS) && !defined(__native_client__) && \
-    defined(__mips__) && \
-    defined(__mips_dsp) && (__mips_dsp_rev >= 2)
-#define HAS_TRANSPOSEWX8_DSPR2
-#define HAS_TRANSPOSEUVWX8_DSPR2
-#endif  // defined(__mips__)
-
-void TransposeWxH_C(const uint8* src, int src_stride,
-                    uint8* dst, int dst_stride, int width, int height);
-
-void TransposeWx8_C(const uint8* src, int src_stride,
-                    uint8* dst, int dst_stride, int width);
-void TransposeWx8_NEON(const uint8* src, int src_stride,
-                       uint8* dst, int dst_stride, int width);
-void TransposeWx8_SSSE3(const uint8* src, int src_stride,
-                        uint8* dst, int dst_stride, int width);
-void TransposeWx8_Fast_SSSE3(const uint8* src, int src_stride,
-                             uint8* dst, int dst_stride, int width);
-void TransposeWx8_DSPR2(const uint8* src, int src_stride,
-                        uint8* dst, int dst_stride, int width);
-void TransposeWx8_Fast_DSPR2(const uint8* src, int src_stride,
-                             uint8* dst, int dst_stride, int width);
-
-void TransposeWx8_Any_NEON(const uint8* src, int src_stride,
-                           uint8* dst, int dst_stride, int width);
-void TransposeWx8_Any_SSSE3(const uint8* src, int src_stride,
-                            uint8* dst, int dst_stride, int width);
-void TransposeWx8_Fast_Any_SSSE3(const uint8* src, int src_stride,
-                                 uint8* dst, int dst_stride, int width);
-void TransposeWx8_Any_DSPR2(const uint8* src, int src_stride,
-                            uint8* dst, int dst_stride, int width);
-
-void TransposeUVWxH_C(const uint8* src, int src_stride,
-                      uint8* dst_a, int dst_stride_a,
-                      uint8* dst_b, int dst_stride_b,
-                      int width, int height);
-
-void TransposeUVWx8_C(const uint8* src, int src_stride,
-                      uint8* dst_a, int dst_stride_a,
-                      uint8* dst_b, int dst_stride_b, int width);
-void TransposeUVWx8_SSE2(const uint8* src, int src_stride,
-                         uint8* dst_a, int dst_stride_a,
-                         uint8* dst_b, int dst_stride_b, int width);
-void TransposeUVWx8_NEON(const uint8* src, int src_stride,
-                         uint8* dst_a, int dst_stride_a,
-                         uint8* dst_b, int dst_stride_b, int width);
-void TransposeUVWx8_DSPR2(const uint8* src, int src_stride,
-                          uint8* dst_a, int dst_stride_a,
-                          uint8* dst_b, int dst_stride_b, int width);
-
-void TransposeUVWx8_Any_SSE2(const uint8* src, int src_stride,
-                             uint8* dst_a, int dst_stride_a,
-                             uint8* dst_b, int dst_stride_b, int width);
-void TransposeUVWx8_Any_NEON(const uint8* src, int src_stride,
-                             uint8* dst_a, int dst_stride_a,
-                             uint8* dst_b, int dst_stride_b, int width);
-void TransposeUVWx8_Any_DSPR2(const uint8* src, int src_stride,
-                              uint8* dst_a, int dst_stride_a,
-                              uint8* dst_b, int dst_stride_b, int width);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_ROTATE_ROW_H_

third_party/libyuv/x86_64/include/libyuv/scale.h

@@ -1,103 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_SCALE_H_
-#define INCLUDE_LIBYUV_SCALE_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-// Supported filtering.
-typedef enum FilterMode {
-  kFilterNone = 0,  // Point sample; Fastest.
-  kFilterLinear = 1,  // Filter horizontally only.
-  kFilterBilinear = 2,  // Faster than box, but lower quality scaling down.
-  kFilterBox = 3  // Highest quality.
-} FilterModeEnum;
-
-// Scale a YUV plane.
-LIBYUV_API
-void ScalePlane(const uint8* src, int src_stride,
-                int src_width, int src_height,
-                uint8* dst, int dst_stride,
-                int dst_width, int dst_height,
-                enum FilterMode filtering);
-
-LIBYUV_API
-void ScalePlane_16(const uint16* src, int src_stride,
-                   int src_width, int src_height,
-                   uint16* dst, int dst_stride,
-                   int dst_width, int dst_height,
-                   enum FilterMode filtering);
-
-// Scales a YUV 4:2:0 image from the src width and height to the
-// dst width and height.
-// If filtering is kFilterNone, a simple nearest-neighbor algorithm is
-// used. This produces basic (blocky) quality at the fastest speed.
-// If filtering is kFilterBilinear, interpolation is used to produce a better
-// quality image, at the expense of speed.
-// If filtering is kFilterBox, averaging is used to produce ever better
-// quality image, at further expense of speed.
-// Returns 0 if successful.
-
-LIBYUV_API
-int I420Scale(const uint8* src_y, int src_stride_y,
-              const uint8* src_u, int src_stride_u,
-              const uint8* src_v, int src_stride_v,
-              int src_width, int src_height,
-              uint8* dst_y, int dst_stride_y,
-              uint8* dst_u, int dst_stride_u,
-              uint8* dst_v, int dst_stride_v,
-              int dst_width, int dst_height,
-              enum FilterMode filtering);
-
-LIBYUV_API
-int I420Scale_16(const uint16* src_y, int src_stride_y,
-                 const uint16* src_u, int src_stride_u,
-                 const uint16* src_v, int src_stride_v,
-                 int src_width, int src_height,
-                 uint16* dst_y, int dst_stride_y,
-                 uint16* dst_u, int dst_stride_u,
-                 uint16* dst_v, int dst_stride_v,
-                 int dst_width, int dst_height,
-                 enum FilterMode filtering);
-
-#ifdef __cplusplus
-// Legacy API.  Deprecated.
-LIBYUV_API
-int Scale(const uint8* src_y, const uint8* src_u, const uint8* src_v,
-          int src_stride_y, int src_stride_u, int src_stride_v,
-          int src_width, int src_height,
-          uint8* dst_y, uint8* dst_u, uint8* dst_v,
-          int dst_stride_y, int dst_stride_u, int dst_stride_v,
-          int dst_width, int dst_height,
-          LIBYUV_BOOL interpolate);
-
-// Legacy API.  Deprecated.
-LIBYUV_API
-int ScaleOffset(const uint8* src_i420, int src_width, int src_height,
-                uint8* dst_i420, int dst_width, int dst_height, int dst_yoffset,
-                LIBYUV_BOOL interpolate);
-
-// For testing, allow disabling of specialized scalers.
-LIBYUV_API
-void SetUseReferenceImpl(LIBYUV_BOOL use);
-#endif  // __cplusplus
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_SCALE_H_

third_party/libyuv/x86_64/include/libyuv/scale_argb.h

@@ -1,56 +0,0 @@
-/*
- *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_SCALE_ARGB_H_
-#define INCLUDE_LIBYUV_SCALE_ARGB_H_
-
-#include "libyuv/basic_types.h"
-#include "libyuv/scale.h"  // For FilterMode
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-LIBYUV_API
-int ARGBScale(const uint8* src_argb, int src_stride_argb,
-              int src_width, int src_height,
-              uint8* dst_argb, int dst_stride_argb,
-              int dst_width, int dst_height,
-              enum FilterMode filtering);
-
-// Clipped scale takes destination rectangle coordinates for clip values.
-LIBYUV_API
-int ARGBScaleClip(const uint8* src_argb, int src_stride_argb,
-                  int src_width, int src_height,
-                  uint8* dst_argb, int dst_stride_argb,
-                  int dst_width, int dst_height,
-                  int clip_x, int clip_y, int clip_width, int clip_height,
-                  enum FilterMode filtering);
-
-// Scale with YUV conversion to ARGB and clipping.
-LIBYUV_API
-int YUVToARGBScaleClip(const uint8* src_y, int src_stride_y,
-                       const uint8* src_u, int src_stride_u,
-                       const uint8* src_v, int src_stride_v,
-                       uint32 src_fourcc,
-                       int src_width, int src_height,
-                       uint8* dst_argb, int dst_stride_argb,
-                       uint32 dst_fourcc,
-                       int dst_width, int dst_height,
-                       int clip_x, int clip_y, int clip_width, int clip_height,
-                       enum FilterMode filtering);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_SCALE_ARGB_H_

third_party/libyuv/x86_64/include/libyuv/scale_row.h

@@ -1,503 +0,0 @@
-/*
- *  Copyright 2013 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_SCALE_ROW_H_
-#define INCLUDE_LIBYUV_SCALE_ROW_H_
-
-#include "libyuv/basic_types.h"
-#include "libyuv/scale.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-#if defined(__pnacl__) || defined(__CLR_VER) || \
-    (defined(__i386__) && !defined(__SSE2__))
-#define LIBYUV_DISABLE_X86
-#endif
-// MemorySanitizer does not support assembly code yet. http://crbug.com/344505
-#if defined(__has_feature)
-#if __has_feature(memory_sanitizer)
-#define LIBYUV_DISABLE_X86
-#endif
-#endif
-
-// GCC >= 4.7.0 required for AVX2.
-#if defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
-#if (__GNUC__ > 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ >= 7))
-#define GCC_HAS_AVX2 1
-#endif  // GNUC >= 4.7
-#endif  // __GNUC__
-
-// clang >= 3.4.0 required for AVX2.
-#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))
-#if (__clang_major__ > 3) || (__clang_major__ == 3 && (__clang_minor__ >= 4))
-#define CLANG_HAS_AVX2 1
-#endif  // clang >= 3.4
-#endif  // __clang__
-
-// Visual C 2012 required for AVX2.
-#if defined(_M_IX86) && !defined(__clang__) && \
-    defined(_MSC_VER) && _MSC_VER >= 1700
-#define VISUALC_HAS_AVX2 1
-#endif  // VisualStudio >= 2012
-
-// The following are available on all x86 platforms:
-#if !defined(LIBYUV_DISABLE_X86) && \
-    (defined(_M_IX86) || defined(__x86_64__) || defined(__i386__))
-#define HAS_FIXEDDIV1_X86
-#define HAS_FIXEDDIV_X86
-#define HAS_SCALEARGBCOLS_SSE2
-#define HAS_SCALEARGBCOLSUP2_SSE2
-#define HAS_SCALEARGBFILTERCOLS_SSSE3
-#define HAS_SCALEARGBROWDOWN2_SSE2
-#define HAS_SCALEARGBROWDOWNEVEN_SSE2
-#define HAS_SCALECOLSUP2_SSE2
-#define HAS_SCALEFILTERCOLS_SSSE3
-#define HAS_SCALEROWDOWN2_SSSE3
-#define HAS_SCALEROWDOWN34_SSSE3
-#define HAS_SCALEROWDOWN38_SSSE3
-#define HAS_SCALEROWDOWN4_SSSE3
-#define HAS_SCALEADDROW_SSE2
-#endif
-
-// The following are available on all x86 platforms, but
-// require VS2012, clang 3.4 or gcc 4.7.
-// The code supports NaCL but requires a new compiler and validator.
-#if !defined(LIBYUV_DISABLE_X86) && (defined(VISUALC_HAS_AVX2) || \
-    defined(CLANG_HAS_AVX2) || defined(GCC_HAS_AVX2))
-#define HAS_SCALEADDROW_AVX2
-#define HAS_SCALEROWDOWN2_AVX2
-#define HAS_SCALEROWDOWN4_AVX2
-#endif
-
-// The following are available on Neon platforms:
-#if !defined(LIBYUV_DISABLE_NEON) && !defined(__native_client__) && \
-    (defined(__ARM_NEON__) || defined(LIBYUV_NEON) || defined(__aarch64__))
-#define HAS_SCALEARGBCOLS_NEON
-#define HAS_SCALEARGBROWDOWN2_NEON
-#define HAS_SCALEARGBROWDOWNEVEN_NEON
-#define HAS_SCALEFILTERCOLS_NEON
-#define HAS_SCALEROWDOWN2_NEON
-#define HAS_SCALEROWDOWN34_NEON
-#define HAS_SCALEROWDOWN38_NEON
-#define HAS_SCALEROWDOWN4_NEON
-#define HAS_SCALEARGBFILTERCOLS_NEON
-#endif
-
-// The following are available on Mips platforms:
-#if !defined(LIBYUV_DISABLE_MIPS) && !defined(__native_client__) && \
-    defined(__mips__) && defined(__mips_dsp) && (__mips_dsp_rev >= 2)
-#define HAS_SCALEROWDOWN2_DSPR2
-#define HAS_SCALEROWDOWN4_DSPR2
-#define HAS_SCALEROWDOWN34_DSPR2
-#define HAS_SCALEROWDOWN38_DSPR2
-#endif
-
-// Scale ARGB vertically with bilinear interpolation.
-void ScalePlaneVertical(int src_height,
-                        int dst_width, int dst_height,
-                        int src_stride, int dst_stride,
-                        const uint8* src_argb, uint8* dst_argb,
-                        int x, int y, int dy,
-                        int bpp, enum FilterMode filtering);
-
-void ScalePlaneVertical_16(int src_height,
-                           int dst_width, int dst_height,
-                           int src_stride, int dst_stride,
-                           const uint16* src_argb, uint16* dst_argb,
-                           int x, int y, int dy,
-                           int wpp, enum FilterMode filtering);
-
-// Simplify the filtering based on scale factors.
-enum FilterMode ScaleFilterReduce(int src_width, int src_height,
-                                  int dst_width, int dst_height,
-                                  enum FilterMode filtering);
-
-// Divide num by div and return as 16.16 fixed point result.
-int FixedDiv_C(int num, int div);
-int FixedDiv_X86(int num, int div);
-// Divide num - 1 by div - 1 and return as 16.16 fixed point result.
-int FixedDiv1_C(int num, int div);
-int FixedDiv1_X86(int num, int div);
-#ifdef HAS_FIXEDDIV_X86
-#define FixedDiv FixedDiv_X86
-#define FixedDiv1 FixedDiv1_X86
-#else
-#define FixedDiv FixedDiv_C
-#define FixedDiv1 FixedDiv1_C
-#endif
-
-// Compute slope values for stepping.
-void ScaleSlope(int src_width, int src_height,
-                int dst_width, int dst_height,
-                enum FilterMode filtering,
-                int* x, int* y, int* dx, int* dy);
-
-void ScaleRowDown2_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                     uint8* dst, int dst_width);
-void ScaleRowDown2_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                        uint16* dst, int dst_width);
-void ScaleRowDown2Linear_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                           uint8* dst, int dst_width);
-void ScaleRowDown2Linear_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                              uint16* dst, int dst_width);
-void ScaleRowDown2Box_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                        uint8* dst, int dst_width);
-void ScaleRowDown2Box_Odd_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst, int dst_width);
-void ScaleRowDown2Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                           uint16* dst, int dst_width);
-void ScaleRowDown4_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                     uint8* dst, int dst_width);
-void ScaleRowDown4_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                        uint16* dst, int dst_width);
-void ScaleRowDown4Box_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                        uint8* dst, int dst_width);
-void ScaleRowDown4Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                           uint16* dst, int dst_width);
-void ScaleRowDown34_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                      uint8* dst, int dst_width);
-void ScaleRowDown34_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                         uint16* dst, int dst_width);
-void ScaleRowDown34_0_Box_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* d, int dst_width);
-void ScaleRowDown34_0_Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                               uint16* d, int dst_width);
-void ScaleRowDown34_1_Box_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* d, int dst_width);
-void ScaleRowDown34_1_Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                               uint16* d, int dst_width);
-void ScaleCols_C(uint8* dst_ptr, const uint8* src_ptr,
-                 int dst_width, int x, int dx);
-void ScaleCols_16_C(uint16* dst_ptr, const uint16* src_ptr,
-                    int dst_width, int x, int dx);
-void ScaleColsUp2_C(uint8* dst_ptr, const uint8* src_ptr,
-                    int dst_width, int, int);
-void ScaleColsUp2_16_C(uint16* dst_ptr, const uint16* src_ptr,
-                       int dst_width, int, int);
-void ScaleFilterCols_C(uint8* dst_ptr, const uint8* src_ptr,
-                       int dst_width, int x, int dx);
-void ScaleFilterCols_16_C(uint16* dst_ptr, const uint16* src_ptr,
-                          int dst_width, int x, int dx);
-void ScaleFilterCols64_C(uint8* dst_ptr, const uint8* src_ptr,
-                         int dst_width, int x, int dx);
-void ScaleFilterCols64_16_C(uint16* dst_ptr, const uint16* src_ptr,
-                            int dst_width, int x, int dx);
-void ScaleRowDown38_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                      uint8* dst, int dst_width);
-void ScaleRowDown38_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                         uint16* dst, int dst_width);
-void ScaleRowDown38_3_Box_C(const uint8* src_ptr,
-                            ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_3_Box_16_C(const uint16* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint16* dst_ptr, int dst_width);
-void ScaleRowDown38_2_Box_C(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_2_Box_16_C(const uint16* src_ptr, ptrdiff_t src_stride,
-                               uint16* dst_ptr, int dst_width);
-void ScaleAddRow_C(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-void ScaleAddRow_16_C(const uint16* src_ptr, uint32* dst_ptr, int src_width);
-void ScaleARGBRowDown2_C(const uint8* src_argb,
-                         ptrdiff_t src_stride,
-                         uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Linear_C(const uint8* src_argb,
-                               ptrdiff_t src_stride,
-                               uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Box_C(const uint8* src_argb, ptrdiff_t src_stride,
-                            uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEven_C(const uint8* src_argb, ptrdiff_t src_stride,
-                            int src_stepx,
-                            uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEvenBox_C(const uint8* src_argb,
-                               ptrdiff_t src_stride,
-                               int src_stepx,
-                               uint8* dst_argb, int dst_width);
-void ScaleARGBCols_C(uint8* dst_argb, const uint8* src_argb,
-                     int dst_width, int x, int dx);
-void ScaleARGBCols64_C(uint8* dst_argb, const uint8* src_argb,
-                       int dst_width, int x, int dx);
-void ScaleARGBColsUp2_C(uint8* dst_argb, const uint8* src_argb,
-                        int dst_width, int, int);
-void ScaleARGBFilterCols_C(uint8* dst_argb, const uint8* src_argb,
-                           int dst_width, int x, int dx);
-void ScaleARGBFilterCols64_C(uint8* dst_argb, const uint8* src_argb,
-                             int dst_width, int x, int dx);
-
-// Specialized scalers for x86.
-void ScaleRowDown2_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                         uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Linear_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Box_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown2_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                        uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Linear_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                              uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Box_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                           uint8* dst_ptr, int dst_width);
-void ScaleRowDown4_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                         uint8* dst_ptr, int dst_width);
-void ScaleRowDown4Box_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown4_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                        uint8* dst_ptr, int dst_width);
-void ScaleRowDown4Box_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                           uint8* dst_ptr, int dst_width);
-
-void ScaleRowDown34_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                          uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_1_Box_SSSE3(const uint8* src_ptr,
-                                ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_0_Box_SSSE3(const uint8* src_ptr,
-                                ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                          uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_3_Box_SSSE3(const uint8* src_ptr,
-                                ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_2_Box_SSSE3(const uint8* src_ptr,
-                                ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown2_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                             uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Linear_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                                   uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Box_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Box_Odd_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown2_Any_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Linear_Any_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                                  uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Box_Any_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-void ScaleRowDown2Box_Odd_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-void ScaleRowDown4_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                             uint8* dst_ptr, int dst_width);
-void ScaleRowDown4Box_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown4_Any_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown4Box_Any_AVX2(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-
-void ScaleRowDown34_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                              uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_1_Box_Any_SSSE3(const uint8* src_ptr,
-                                    ptrdiff_t src_stride,
-                                    uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_0_Box_Any_SSSE3(const uint8* src_ptr,
-                                    ptrdiff_t src_stride,
-                                    uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_Any_SSSE3(const uint8* src_ptr, ptrdiff_t src_stride,
-                              uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_3_Box_Any_SSSE3(const uint8* src_ptr,
-                                    ptrdiff_t src_stride,
-                                    uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_2_Box_Any_SSSE3(const uint8* src_ptr,
-                                    ptrdiff_t src_stride,
-                                    uint8* dst_ptr, int dst_width);
-
-void ScaleAddRow_SSE2(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-void ScaleAddRow_AVX2(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-void ScaleAddRow_Any_SSE2(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-void ScaleAddRow_Any_AVX2(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-
-void ScaleFilterCols_SSSE3(uint8* dst_ptr, const uint8* src_ptr,
-                           int dst_width, int x, int dx);
-void ScaleColsUp2_SSE2(uint8* dst_ptr, const uint8* src_ptr,
-                       int dst_width, int x, int dx);
-
-
-// ARGB Column functions
-void ScaleARGBCols_SSE2(uint8* dst_argb, const uint8* src_argb,
-                        int dst_width, int x, int dx);
-void ScaleARGBFilterCols_SSSE3(uint8* dst_argb, const uint8* src_argb,
-                               int dst_width, int x, int dx);
-void ScaleARGBColsUp2_SSE2(uint8* dst_argb, const uint8* src_argb,
-                           int dst_width, int x, int dx);
-void ScaleARGBFilterCols_NEON(uint8* dst_argb, const uint8* src_argb,
-                              int dst_width, int x, int dx);
-void ScaleARGBCols_NEON(uint8* dst_argb, const uint8* src_argb,
-                        int dst_width, int x, int dx);
-void ScaleARGBFilterCols_Any_NEON(uint8* dst_argb, const uint8* src_argb,
-                                  int dst_width, int x, int dx);
-void ScaleARGBCols_Any_NEON(uint8* dst_argb, const uint8* src_argb,
-                            int dst_width, int x, int dx);
-
-// ARGB Row functions
-void ScaleARGBRowDown2_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                            uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Linear_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                                  uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Box_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                               uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst, int dst_width);
-void ScaleARGBRowDown2Linear_NEON(const uint8* src_argb, ptrdiff_t src_stride,
-                                  uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Box_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst, int dst_width);
-void ScaleARGBRowDown2_Any_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                                uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Linear_Any_SSE2(const uint8* src_argb,
-                                      ptrdiff_t src_stride,
-                                      uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Box_Any_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                                   uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* dst, int dst_width);
-void ScaleARGBRowDown2Linear_Any_NEON(const uint8* src_argb,
-                                      ptrdiff_t src_stride,
-                                      uint8* dst_argb, int dst_width);
-void ScaleARGBRowDown2Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                                   uint8* dst, int dst_width);
-
-void ScaleARGBRowDownEven_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                               int src_stepx, uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEvenBox_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                                  int src_stepx,
-                                  uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEven_NEON(const uint8* src_argb, ptrdiff_t src_stride,
-                               int src_stepx,
-                               uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEvenBox_NEON(const uint8* src_argb, ptrdiff_t src_stride,
-                                  int src_stepx,
-                                  uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEven_Any_SSE2(const uint8* src_argb, ptrdiff_t src_stride,
-                                   int src_stepx,
-                                   uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEvenBox_Any_SSE2(const uint8* src_argb,
-                                      ptrdiff_t src_stride,
-                                      int src_stepx,
-                                      uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEven_Any_NEON(const uint8* src_argb, ptrdiff_t src_stride,
-                                   int src_stepx,
-                                   uint8* dst_argb, int dst_width);
-void ScaleARGBRowDownEvenBox_Any_NEON(const uint8* src_argb,
-                                      ptrdiff_t src_stride,
-                                      int src_stepx,
-                                      uint8* dst_argb, int dst_width);
-
-// ScaleRowDown2Box also used by planar functions
-// NEON downscalers with interpolation.
-
-// Note - not static due to reuse in convert for 444 to 420.
-void ScaleRowDown2_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                        uint8* dst, int dst_width);
-void ScaleRowDown2Linear_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                              uint8* dst, int dst_width);
-void ScaleRowDown2Box_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                           uint8* dst, int dst_width);
-
-void ScaleRowDown4_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                        uint8* dst_ptr, int dst_width);
-void ScaleRowDown4Box_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                           uint8* dst_ptr, int dst_width);
-
-// Down scale from 4 to 3 pixels. Use the neon multilane read/write
-//  to load up the every 4th pixel into a 4 different registers.
-// Point samples 32 pixels to 24 pixels.
-void ScaleRowDown34_NEON(const uint8* src_ptr,
-                         ptrdiff_t src_stride,
-                         uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_0_Box_NEON(const uint8* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_1_Box_NEON(const uint8* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-
-// 32 -> 12
-void ScaleRowDown38_NEON(const uint8* src_ptr,
-                         ptrdiff_t src_stride,
-                         uint8* dst_ptr, int dst_width);
-// 32x3 -> 12x1
-void ScaleRowDown38_3_Box_NEON(const uint8* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-// 32x2 -> 12x1
-void ScaleRowDown38_2_Box_NEON(const uint8* src_ptr,
-                               ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-
-void ScaleRowDown2_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst, int dst_width);
-void ScaleRowDown2Linear_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                                  uint8* dst, int dst_width);
-void ScaleRowDown2Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst, int dst_width);
-void ScaleRowDown2Box_Odd_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst, int dst_width);
-void ScaleRowDown4_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst_ptr, int dst_width);
-void ScaleRowDown4Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                             uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_0_Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                                   uint8* dst_ptr, int dst_width);
-void ScaleRowDown34_1_Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                                   uint8* dst_ptr, int dst_width);
-// 32 -> 12
-void ScaleRowDown38_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                             uint8* dst_ptr, int dst_width);
-// 32x3 -> 12x1
-void ScaleRowDown38_3_Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-// 32x2 -> 12x1
-void ScaleRowDown38_2_Box_Any_NEON(const uint8* src_ptr, ptrdiff_t src_stride,
-                               uint8* dst_ptr, int dst_width);
-
-void ScaleAddRow_NEON(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-void ScaleAddRow_Any_NEON(const uint8* src_ptr, uint16* dst_ptr, int src_width);
-
-void ScaleFilterCols_NEON(uint8* dst_ptr, const uint8* src_ptr,
-                          int dst_width, int x, int dx);
-
-void ScaleFilterCols_Any_NEON(uint8* dst_ptr, const uint8* src_ptr,
-                              int dst_width, int x, int dx);
-
-void ScaleRowDown2_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                         uint8* dst, int dst_width);
-void ScaleRowDown2Box_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst, int dst_width);
-void ScaleRowDown4_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                         uint8* dst, int dst_width);
-void ScaleRowDown4Box_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                            uint8* dst, int dst_width);
-void ScaleRowDown34_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                          uint8* dst, int dst_width);
-void ScaleRowDown34_0_Box_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* d, int dst_width);
-void ScaleRowDown34_1_Box_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* d, int dst_width);
-void ScaleRowDown38_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                          uint8* dst, int dst_width);
-void ScaleRowDown38_2_Box_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-void ScaleRowDown38_3_Box_DSPR2(const uint8* src_ptr, ptrdiff_t src_stride,
-                                uint8* dst_ptr, int dst_width);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_SCALE_ROW_H_

third_party/libyuv/x86_64/include/libyuv/version.h

@@ -1,16 +0,0 @@
-/*
- *  Copyright 2012 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef INCLUDE_LIBYUV_VERSION_H_
-#define INCLUDE_LIBYUV_VERSION_H_
-
-#define LIBYUV_VERSION 1622
-
-#endif  // INCLUDE_LIBYUV_VERSION_H_

third_party/libyuv/x86_64/include/libyuv/video_common.h

@@ -1,184 +0,0 @@
-/*
- *  Copyright 2011 The LibYuv Project Authors. All rights reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS. All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-// Common definitions for video, including fourcc and VideoFormat.
-
-#ifndef INCLUDE_LIBYUV_VIDEO_COMMON_H_
-#define INCLUDE_LIBYUV_VIDEO_COMMON_H_
-
-#include "libyuv/basic_types.h"
-
-#ifdef __cplusplus
-namespace libyuv {
-extern "C" {
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-// Definition of FourCC codes
-//////////////////////////////////////////////////////////////////////////////
-
-// Convert four characters to a FourCC code.
-// Needs to be a macro otherwise the OS X compiler complains when the kFormat*
-// constants are used in a switch.
-#ifdef __cplusplus
-#define FOURCC(a, b, c, d) ( \
-    (static_cast<uint32>(a)) | (static_cast<uint32>(b) << 8) | \
-    (static_cast<uint32>(c) << 16) | (static_cast<uint32>(d) << 24))
-#else
-#define FOURCC(a, b, c, d) ( \
-    ((uint32)(a)) | ((uint32)(b) << 8) | /* NOLINT */ \
-    ((uint32)(c) << 16) | ((uint32)(d) << 24))  /* NOLINT */
-#endif
-
-// Some pages discussing FourCC codes:
-//   http://www.fourcc.org/yuv.php
-//   http://v4l2spec.bytesex.org/spec/book1.htm
-//   http://developer.apple.com/quicktime/icefloe/dispatch020.html
-//   http://msdn.microsoft.com/library/windows/desktop/dd206750.aspx#nv12
-//   http://people.xiph.org/~xiphmont/containers/nut/nut4cc.txt
-
-// FourCC codes grouped according to implementation efficiency.
-// Primary formats should convert in 1 efficient step.
-// Secondary formats are converted in 2 steps.
-// Auxilliary formats call primary converters.
-enum FourCC {
-  // 9 Primary YUV formats: 5 planar, 2 biplanar, 2 packed.
-  FOURCC_I420 = FOURCC('I', '4', '2', '0'),
-  FOURCC_I422 = FOURCC('I', '4', '2', '2'),
-  FOURCC_I444 = FOURCC('I', '4', '4', '4'),
-  FOURCC_I411 = FOURCC('I', '4', '1', '1'),
-  FOURCC_I400 = FOURCC('I', '4', '0', '0'),
-  FOURCC_NV21 = FOURCC('N', 'V', '2', '1'),
-  FOURCC_NV12 = FOURCC('N', 'V', '1', '2'),
-  FOURCC_YUY2 = FOURCC('Y', 'U', 'Y', '2'),
-  FOURCC_UYVY = FOURCC('U', 'Y', 'V', 'Y'),
-
-  // 2 Secondary YUV formats: row biplanar.
-  FOURCC_M420 = FOURCC('M', '4', '2', '0'),
-  FOURCC_Q420 = FOURCC('Q', '4', '2', '0'),  // deprecated.
-
-  // 9 Primary RGB formats: 4 32 bpp, 2 24 bpp, 3 16 bpp.
-  FOURCC_ARGB = FOURCC('A', 'R', 'G', 'B'),
-  FOURCC_BGRA = FOURCC('B', 'G', 'R', 'A'),
-  FOURCC_ABGR = FOURCC('A', 'B', 'G', 'R'),
-  FOURCC_24BG = FOURCC('2', '4', 'B', 'G'),
-  FOURCC_RAW  = FOURCC('r', 'a', 'w', ' '),
-  FOURCC_RGBA = FOURCC('R', 'G', 'B', 'A'),
-  FOURCC_RGBP = FOURCC('R', 'G', 'B', 'P'),  // rgb565 LE.
-  FOURCC_RGBO = FOURCC('R', 'G', 'B', 'O'),  // argb1555 LE.
-  FOURCC_R444 = FOURCC('R', '4', '4', '4'),  // argb4444 LE.
-
-  // 4 Secondary RGB formats: 4 Bayer Patterns. deprecated.
-  FOURCC_RGGB = FOURCC('R', 'G', 'G', 'B'),
-  FOURCC_BGGR = FOURCC('B', 'G', 'G', 'R'),
-  FOURCC_GRBG = FOURCC('G', 'R', 'B', 'G'),
-  FOURCC_GBRG = FOURCC('G', 'B', 'R', 'G'),
-
-  // 1 Primary Compressed YUV format.
-  FOURCC_MJPG = FOURCC('M', 'J', 'P', 'G'),
-
-  // 5 Auxiliary YUV variations: 3 with U and V planes are swapped, 1 Alias.
-  FOURCC_YV12 = FOURCC('Y', 'V', '1', '2'),
-  FOURCC_YV16 = FOURCC('Y', 'V', '1', '6'),
-  FOURCC_YV24 = FOURCC('Y', 'V', '2', '4'),
-  FOURCC_YU12 = FOURCC('Y', 'U', '1', '2'),  // Linux version of I420.
-  FOURCC_J420 = FOURCC('J', '4', '2', '0'),
-  FOURCC_J400 = FOURCC('J', '4', '0', '0'),  // unofficial fourcc
-  FOURCC_H420 = FOURCC('H', '4', '2', '0'),  // unofficial fourcc
-
-  // 14 Auxiliary aliases.  CanonicalFourCC() maps these to canonical fourcc.
-  FOURCC_IYUV = FOURCC('I', 'Y', 'U', 'V'),  // Alias for I420.
-  FOURCC_YU16 = FOURCC('Y', 'U', '1', '6'),  // Alias for I422.
-  FOURCC_YU24 = FOURCC('Y', 'U', '2', '4'),  // Alias for I444.
-  FOURCC_YUYV = FOURCC('Y', 'U', 'Y', 'V'),  // Alias for YUY2.
-  FOURCC_YUVS = FOURCC('y', 'u', 'v', 's'),  // Alias for YUY2 on Mac.
-  FOURCC_HDYC = FOURCC('H', 'D', 'Y', 'C'),  // Alias for UYVY.
-  FOURCC_2VUY = FOURCC('2', 'v', 'u', 'y'),  // Alias for UYVY on Mac.
-  FOURCC_JPEG = FOURCC('J', 'P', 'E', 'G'),  // Alias for MJPG.
-  FOURCC_DMB1 = FOURCC('d', 'm', 'b', '1'),  // Alias for MJPG on Mac.
-  FOURCC_BA81 = FOURCC('B', 'A', '8', '1'),  // Alias for BGGR.
-  FOURCC_RGB3 = FOURCC('R', 'G', 'B', '3'),  // Alias for RAW.
-  FOURCC_BGR3 = FOURCC('B', 'G', 'R', '3'),  // Alias for 24BG.
-  FOURCC_CM32 = FOURCC(0, 0, 0, 32),  // Alias for BGRA kCMPixelFormat_32ARGB
-  FOURCC_CM24 = FOURCC(0, 0, 0, 24),  // Alias for RAW kCMPixelFormat_24RGB
-  FOURCC_L555 = FOURCC('L', '5', '5', '5'),  // Alias for RGBO.
-  FOURCC_L565 = FOURCC('L', '5', '6', '5'),  // Alias for RGBP.
-  FOURCC_5551 = FOURCC('5', '5', '5', '1'),  // Alias for RGBO.
-
-  // 1 Auxiliary compressed YUV format set aside for capturer.
-  FOURCC_H264 = FOURCC('H', '2', '6', '4'),
-
-  // Match any fourcc.
-  FOURCC_ANY = -1,
-};
-
-enum FourCCBpp {
-  // Canonical fourcc codes used in our code.
-  FOURCC_BPP_I420 = 12,
-  FOURCC_BPP_I422 = 16,
-  FOURCC_BPP_I444 = 24,
-  FOURCC_BPP_I411 = 12,
-  FOURCC_BPP_I400 = 8,
-  FOURCC_BPP_NV21 = 12,
-  FOURCC_BPP_NV12 = 12,
-  FOURCC_BPP_YUY2 = 16,
-  FOURCC_BPP_UYVY = 16,
-  FOURCC_BPP_M420 = 12,
-  FOURCC_BPP_Q420 = 12,
-  FOURCC_BPP_ARGB = 32,
-  FOURCC_BPP_BGRA = 32,
-  FOURCC_BPP_ABGR = 32,
-  FOURCC_BPP_RGBA = 32,
-  FOURCC_BPP_24BG = 24,
-  FOURCC_BPP_RAW  = 24,
-  FOURCC_BPP_RGBP = 16,
-  FOURCC_BPP_RGBO = 16,
-  FOURCC_BPP_R444 = 16,
-  FOURCC_BPP_RGGB = 8,
-  FOURCC_BPP_BGGR = 8,
-  FOURCC_BPP_GRBG = 8,
-  FOURCC_BPP_GBRG = 8,
-  FOURCC_BPP_YV12 = 12,
-  FOURCC_BPP_YV16 = 16,
-  FOURCC_BPP_YV24 = 24,
-  FOURCC_BPP_YU12 = 12,
-  FOURCC_BPP_J420 = 12,
-  FOURCC_BPP_J400 = 8,
-  FOURCC_BPP_H420 = 12,
-  FOURCC_BPP_MJPG = 0,  // 0 means unknown.
-  FOURCC_BPP_H264 = 0,
-  FOURCC_BPP_IYUV = 12,
-  FOURCC_BPP_YU16 = 16,
-  FOURCC_BPP_YU24 = 24,
-  FOURCC_BPP_YUYV = 16,
-  FOURCC_BPP_YUVS = 16,
-  FOURCC_BPP_HDYC = 16,
-  FOURCC_BPP_2VUY = 16,
-  FOURCC_BPP_JPEG = 1,
-  FOURCC_BPP_DMB1 = 1,
-  FOURCC_BPP_BA81 = 8,
-  FOURCC_BPP_RGB3 = 24,
-  FOURCC_BPP_BGR3 = 24,
-  FOURCC_BPP_CM32 = 32,
-  FOURCC_BPP_CM24 = 24,
-
-  // Match any fourcc.
-  FOURCC_BPP_ANY  = 0,  // 0 means unknown.
-};
-
-// Converts fourcc aliases into canonical ones.
-LIBYUV_API uint32 CanonicalFourCC(uint32 fourcc);
-
-#ifdef __cplusplus
-}  // extern "C"
-}  // namespace libyuv
-#endif
-
-#endif  // INCLUDE_LIBYUV_VIDEO_COMMON_H_