#!/usr/bin/env python3
"""
Camera Station — a tiny self-hosted front end for MJPEG and RTSP cameras.

Why a server instead of just opening the HTML file?

  1. Browsers "taint" a <canvas> that has drawn an image from another origin,
     and a tainted canvas cannot be read back — which would break both photo
     capture and recording. Serving the page and the video from one origin
     keeps the canvas readable.
  2. No browser can play RTSP. RTSP cameras are decoded by ffmpeg here and
     handed to the page as MJPEG, so every camera behaves the same way.

Camera credentials stay in this process and are never sent to the page.

Usage:
    python3 server.py
    python3 server.py --camera "Front door=http://192.168.69.79:8080"
    python3 server.py --camera "Drive=rtsp://user:pass@192.168.69.128:554/cam"
    python3 server.py --host 127.0.0.1        # only this machine can connect

Then open http://localhost:8000
Standard library only. ffmpeg is needed for RTSP cameras, nothing else.
"""

import argparse
import json
import os
import re
import shutil
import socket
import subprocess
import sys
import threading
import time
import uuid
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from queue import Queue, Empty
from urllib.error import URLError, HTTPError
from urllib.parse import urlparse, parse_qs, quote, unquote
from urllib.request import urlopen

HERE = os.path.dirname(os.path.abspath(__file__))
PAGE = os.path.join(HERE, "index.html")
CONFIG_PAGE = os.path.join(HERE, "config.html")
LIBRARY_PAGE = os.path.join(HERE, "library.html")

# Everything the service produces lives under one directory, so a container can
# mount a single volume and keep recordings, photos and settings together.
DATA_DIR = os.environ.get("CAMERA_STATION_DATA") or os.path.join(HERE, "data")
CONFIG_FILE = os.path.join(DATA_DIR, "cameras.json")
LEGACY_CONFIG = os.path.join(HERE, "cameras.json")
RECORD_DIR = os.path.join(DATA_DIR, "recordings")
PHOTO_DIR = os.path.join(DATA_DIR, "photos")

STORAGE_LIMIT = 10 * 1024 ** 3      # 10 GB of footage, oldest deleted first
SEGMENT_SECONDS = 600               # a new file every 10 minutes, at a keyframe
SWEEP_SECONDS = 20                  # how often storage is checked


def ensure_dirs():
    for path in (DATA_DIR, RECORD_DIR, PHOTO_DIR):
        os.makedirs(path, exist_ok=True)


def slug(text):
    out = re.sub(r"[^A-Za-z0-9]+", "-", (text or "").strip()).strip("-")
    return out or "camera"

DEFAULT_CAMERAS = [
    ("Camera 1", "http://192.168.69.79:8080"),
    ("Camera 2", "rtsp://admin:Admin100pass!@192.168.69.128:554"
                 "/cam/realmonitor?channel=1&subtype=0"),
]

BOUNDARY = "camerastation"


# --------------------------------------------------------------------------
# helpers
# --------------------------------------------------------------------------

def recording_state(cam):
    rec = getattr(cam, "recorder", None)
    status = rec.status() if rec else {}
    return {"active": bool(getattr(cam, "active", False)),
            "recording": bool(status.get("running")),
            "since": status.get("since"),
            "recordError": status.get("error")}


def safe_host(url):
    """The address with any user:password stripped, for display in the page."""
    try:
        p = urlparse(url)
        host = p.hostname or ""
        if p.port:
            host += ":%d" % p.port
        return host or "camera"
    except ValueError:
        return "camera"


def ffmpeg_available():
    return shutil.which("ffmpeg") is not None


def ffmpeg_timeout_flag():
    """ffmpeg 6 renamed the RTSP socket timeout from -stimeout to -timeout."""
    try:
        out = subprocess.run(["ffmpeg", "-version"], capture_output=True,
                             text=True, timeout=5).stdout
        m = re.search(r"ffmpeg version n?(\d+)", out)
        if m and int(m.group(1)) >= 6:
            return "-timeout"
    except Exception:
        pass
    return "-stimeout"


# The config page has to show existing cameras without handing their passwords
# to a browser, so a saved password is displayed as bullets and only travels in
# one direction: you can set a new one, but you can never read the old one back.
KEPT_SECRET = "\u2022" * 8
URL_PARTS = re.compile(r"^([a-zA-Z][a-zA-Z0-9+.\-]*://)([^/@]*@)?(.*)$", re.S)


def redact_url(url):
    """Replace any password in a URL with bullets."""
    m = URL_PARTS.match(url or "")
    if not m:
        return url
    scheme, userinfo, rest = m.group(1), m.group(2) or "", m.group(3)
    creds = userinfo[:-1]
    if ":" not in creds:
        return url
    return scheme + creds.split(":", 1)[0] + ":" + KEPT_SECRET + "@" + rest


def restore_url(url, previous):
    """Put the stored password back if the page sent the bullets untouched."""
    m = URL_PARTS.match(url or "")
    if not m:
        return url
    scheme, userinfo, rest = m.group(1), m.group(2) or "", m.group(3)
    creds = userinfo[:-1]
    if ":" not in creds:
        return url
    user, password = creds.split(":", 1)
    if password != KEPT_SECRET:
        return url                      # a new password was typed; use it
    prev = URL_PARTS.match(previous or "")
    if prev and prev.group(2) and ":" in prev.group(2)[:-1]:
        old = prev.group(2)[:-1].split(":", 1)[1]
        return scheme + user + ":" + old + "@" + rest
    return scheme + user + "@" + rest   # nothing stored to restore


def valid_url(url):
    url = (url or "").strip()
    return url.startswith(("http://", "https://", "rtsp://", "rtsps://"))


def load_config():
    """Cameras saved by the config page, or None if there are none yet."""
    data = None
    for path in (CONFIG_FILE, LEGACY_CONFIG):
        try:
            with open(path, "r", encoding="utf-8") as fh:
                data = json.load(fh)
            break
        except (OSError, ValueError):
            continue
    if data is None:
        return None
    entries = data.get("cameras") if isinstance(data, dict) else data
    if not isinstance(entries, list):
        return None
    out = []
    for e in entries:
        if isinstance(e, dict) and valid_url(e.get("url")):
            out.append({"id": str(e.get("id") or new_id()),
                        "name": str(e.get("name") or "Camera").strip() or "Camera",
                        "url": e["url"].strip(),
                        "active": bool(e.get("active"))})
    return out or None


def save_config(entries):
    """Write the camera list, via a temporary file so a crash cannot truncate it."""
    ensure_dirs()
    tmp = CONFIG_FILE + ".tmp"
    with open(tmp, "w", encoding="utf-8") as fh:
        json.dump({"cameras": entries}, fh, indent=2)
        fh.flush()
        os.fsync(fh.fileno())
    os.replace(tmp, CONFIG_FILE)


def new_id():
    return "cam" + uuid.uuid4().hex[:6]


def jpeg_size(data):
    """Width and height from JPEG headers, without pulling in an image library."""
    i, n = 2, len(data)
    while i + 9 < n:
        if data[i] != 0xFF:
            i += 1
            continue
        marker = data[i + 1]
        if marker in (0xD8, 0xD9) or 0xD0 <= marker <= 0xD7:
            i += 2
            continue
        if marker in (0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6,
                      0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF):
            return (int.from_bytes(data[i + 7:i + 9], "big"),
                    int.from_bytes(data[i + 5:i + 7], "big"))
        i += 2 + int.from_bytes(data[i + 2:i + 4], "big")
    return None


# --------------------------------------------------------------------------
# cameras
# --------------------------------------------------------------------------

class MjpegCamera:
    """An MJPG-Streamer style feed. Relayed byte for byte — nothing re-encoded."""

    kind = "mjpeg"

    def __init__(self, cid, name, url):
        self.id = cid
        self.name = name
        self.url = url.rstrip("/")
        self.available = True
        self.reason = None

    def describe(self):
        return dict(recording_state(self),
                    id=self.id, name=self.name, kind=self.kind,
                    host=safe_host(self.url), available=self.available,
                    reason=self.reason)

    def open_upstream(self, action):
        return urlopen(self.url + "/?action=" + action, timeout=10)


class RtspCamera:
    """
    An RTSP camera, decoded by ffmpeg and re-published as MJPEG.

    One ffmpeg process per camera, shared by every viewer, started on the first
    subscriber and stopped shortly after the last one leaves. Decoding an H.264
    stream twice because two tabs are open would be wasteful, and most cameras
    limit how many RTSP sessions they will serve at once.
    """

    kind = "rtsp"
    IDLE_GRACE = 8.0          # seconds to keep ffmpeg alive after the last viewer

    # ffmpeg is chatty about things that are not faults. Two kinds dominate:
    #
    #   * Decoder complaints while it waits for the first keyframe. Joining an
    #     H.264/HEVC stream mid-GOP means the first frames reference pictures
    #     that were sent before we connected. This clears itself the moment an
    #     IDR arrives, usually within a second or two.
    #   * Broken pipe, on the way down. When a camera is released, its stdout is
    #     closed, and ffmpeg reports every stage of noticing that.
    #
    # Neither says anything useful about whether the camera works, and treating
    # them as errors puts nonsense like "Error closing file" on screen as the
    # reason a camera is unavailable.
    DECODER_NOISE = (
        "could not find ref with poc",
        "error constructing the frame rps",
        "missing reference picture",
        "reference picture missing",
        "co located pocs unavailable",
        "decode_slice_header error",
        "no frame!",
        "mmco: unref short failure",
        "illegal short term buffer state",
        "error while decoding mb",
        "concealing",
        "corrupt decoded frame",
        "non-existing pps",
        "sps unavailable",
        "deprecated pixel format",
        "last message repeated",
    )
    SHUTDOWN_NOISE = (
        "broken pipe",
        "error muxing a packet",
        "task finished with error code",
        "terminating thread with return code",
        "error writing trailer",
        "error closing file",
        "error submitting a packet to the muxer",
    )

    @classmethod
    def is_noise(cls, text):
        low = text.lower()
        return any(p in low for p in cls.DECODER_NOISE + cls.SHUTDOWN_NOISE)

    def __init__(self, cid, name, url, quality=3, fps=None, size=None, verbose=False):
        self.id = cid
        self.name = name
        self.url = url
        self.quality = quality
        self.fps = fps
        self.size = size
        self.verbose = verbose
        self.noise_count = 0

        self.available = ffmpeg_available()
        self.reason = None if self.available else \
            "ffmpeg is not installed, so this RTSP camera cannot be decoded."

        self._lock = threading.RLock()
        self._subs = set()
        self._proc = None
        self._stopper = None
        self._latest = None
        self._latest_at = 0
        self._first_frame = threading.Event()
        self._timeout_flag = ffmpeg_timeout_flag() if self.available else None
        self._last_error = None

    # ---- description ----

    def describe(self):
        return dict(recording_state(self),
                    id=self.id, name=self.name, kind=self.kind,
                    host=safe_host(self.url), available=self.available,
                    reason=self.reason or self._last_error)

    # ---- process control ----

    def input_args(self, timeout_flag):
        """Overridable so tests can substitute a synthetic source."""
        return [timeout_flag, "5000000", "-rtsp_transport", "tcp", "-i", self.url]

    def _command(self, timeout_flag):
        args = ["ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error",
                "-fflags", "nobuffer+discardcorrupt"]
        args += self.input_args(timeout_flag)
        args += ["-an"]
        if self.fps:
            args += ["-r", str(self.fps)]
        if self.size:
            args += ["-s", self.size]
        args += ["-f", "mpjpeg", "-q:v", str(self.quality), "-"]
        return args

    def _spawn(self):
        """Start ffmpeg, retrying once if the timeout flag is the wrong spelling."""
        alt = "-stimeout" if self._timeout_flag == "-timeout" else "-timeout"
        proc = None
        for flag in (self._timeout_flag, alt):
            proc = subprocess.Popen(self._command(flag),
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.PIPE,
                                    bufsize=0)
            time.sleep(0.3)
            if proc.poll() is None:
                self._timeout_flag = flag
                return proc
            err = (proc.stderr.read() or b"").decode("utf-8", "replace")
            if "Unrecognized option" not in err and "Option not found" not in err:
                lines = [l for l in err.strip().splitlines() if l.strip()]
                self._last_error = lines[-1] if lines else "ffmpeg exited immediately."
                return proc
        return proc

    def _ensure_running(self):
        with self._lock:
            if self._stopper:
                self._stopper.cancel()
                self._stopper = None
            if self._proc and self._proc.poll() is None:
                return
            self._first_frame.clear()
            self._proc = self._spawn()
            threading.Thread(target=self._pump, args=(self._proc,), daemon=True).start()
            threading.Thread(target=self._drain_errors, args=(self._proc,), daemon=True).start()

    def _schedule_stop(self):
        with self._lock:
            if self._stopper:
                self._stopper.cancel()
            self._stopper = threading.Timer(self.IDLE_GRACE, self._stop_if_idle)
            self._stopper.daemon = True
            self._stopper.start()

    def _stop_if_idle(self):
        with self._lock:
            if self._subs:
                return
            proc, self._proc = self._proc, None
            self._latest = None
        if proc and proc.poll() is None:
            proc.cs_stopping = True
            proc.terminate()
            try:
                proc.wait(timeout=3)
            except subprocess.TimeoutExpired:
                proc.kill()

    def shutdown(self):
        """Stop for good, even if someone is still watching (config changed)."""
        with self._lock:
            self._subs.clear()
        self._stop_if_idle()

    def _drain_errors(self, proc):
        try:
            for line in iter(proc.stderr.readline, b""):
                text = line.decode("utf-8", "replace").strip()
                if not text:
                    continue
                if getattr(proc, "cs_stopping", False):
                    # We asked this process to stop. Whatever it says on the way
                    # out is expected, so it is not worth alarming anyone with.
                    continue
                if self.is_noise(text):
                    self.noise_count += 1
                    if self.verbose:
                        sys.stderr.write("  [%s] %s\n" % (self.id, text))
                    continue
                self._last_error = text
                sys.stderr.write("  [%s] %s\n" % (self.id, text))
        except Exception:
            pass

    # ---- mpjpeg parsing ----

    def _pump(self, proc):
        """
        Read ffmpeg's multipart output and hand whole JPEG frames to viewers.

        Frames are split on the Content-length header rather than by hunting for
        JPEG end markers, because those bytes can occur inside compressed data.
        """
        out = proc.stdout
        try:
            while True:
                line = out.readline()
                if not line:
                    break
                low = line.strip().lower()
                if not low.startswith(b"content-length"):
                    continue
                try:
                    size = int(low.split(b":", 1)[1])
                except (IndexError, ValueError):
                    continue
                while True:                       # skip to the blank separator
                    sep = out.readline()
                    if not sep or sep in (b"\r\n", b"\n"):
                        break
                frame = out.read(size)
                if not frame or len(frame) < size:
                    break
                self._publish(frame)
        except Exception as err:
            self._last_error = str(err)
        finally:
            try:
                out.close()
            except Exception:
                pass

    def _publish(self, frame):
        # Pictures are arriving, so any earlier complaint is history.
        if self._last_error is not None:
            self._last_error = None
        self._latest = frame
        self._latest_at = time.time()
        self._first_frame.set()
        for q in list(self._subs):
            if q.full():
                try:
                    q.get_nowait()     # drop the stale frame, never the fresh one
                except Empty:
                    pass
            try:
                q.put_nowait(frame)
            except Exception:
                pass

    # ---- viewer API ----

    def subscribe(self):
        q = Queue(maxsize=1)
        with self._lock:
            self._subs.add(q)
        self._ensure_running()
        return q

    def unsubscribe(self, q):
        with self._lock:
            self._subs.discard(q)
            idle = not self._subs
        if idle:
            self._schedule_stop()

    def snapshot(self, wait=10.0):
        """Latest decoded frame, starting the camera briefly if nobody is watching."""
        if self._latest is not None and time.time() - self._latest_at < 5:
            return self._latest
        q = self.subscribe()
        try:
            self._first_frame.wait(wait)
            return self._latest
        finally:
            self.unsubscribe(q)

    def viewers(self):
        with self._lock:
            return len(self._subs)

    def is_running(self):
        with self._lock:
            return bool(self._proc and self._proc.poll() is None)



# --------------------------------------------------------------------------
# continuous recording
# --------------------------------------------------------------------------

class Recorder:
    """
    Writes a camera to disk continuously while it is marked active.

    The stream is copied, not re-encoded: what lands on disk is exactly the
    bitstream the camera sent, at no quality cost and almost no CPU. That also
    means an active camera costs nearly nothing until somebody actually watches
    it, because only watching requires decoding.

    Footage is cut into timestamped segments so old material can be deleted a
    piece at a time. Matroska is used rather than MP4 because a segment that is
    still being written stays readable if the service is stopped or the machine
    loses power; an unfinalised MP4 would not.
    """

    RESTART_DELAY = 5.0

    def __init__(self, cam):
        self.cam = cam
        self.proc = None
        self.started_at = 0
        self.error = None
        self.folder_name = slug(cam.name)
        self._lock = threading.RLock()
        self._last_attempt = 0

    @property
    def folder(self):
        return os.path.join(RECORD_DIR, self.folder_name)

    def is_running(self):
        with self._lock:
            return bool(self.proc and self.proc.poll() is None)

    def command(self):
        args = ["ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error"]
        if self.cam.kind == "rtsp":
            args += [ffmpeg_timeout_flag(), "5000000",
                     "-rtsp_transport", "tcp", "-i", self.cam.url]
        else:
            # An HTTP MJPEG feed carries no timestamps of its own, so take them
            # from the clock; without this the file plays back at the wrong speed.
            args += ["-use_wallclock_as_timestamps", "1",
                     "-f", "mjpeg", "-i", self.cam.url + "/?action=stream"]
        args += ["-an", "-c", "copy",
                 "-f", "segment", "-strftime", "1",
                 "-segment_time", str(SEGMENT_SECONDS),
                 "-segment_format", "matroska",
                 "-reset_timestamps", "1",
                 os.path.join(self.folder, "%Y%m%d-%H%M%S.mkv")]
        return args

    def start(self):
        with self._lock:
            if self.is_running():
                return
            if time.time() - self._last_attempt < self.RESTART_DELAY:
                return                     # a camera that keeps failing is not hammered
            self._last_attempt = time.time()
            if not ffmpeg_available():
                self.error = "ffmpeg is not installed, so nothing can be recorded."
                return
            os.makedirs(self.folder, exist_ok=True)
            try:
                self.proc = subprocess.Popen(self.command(), stdout=subprocess.DEVNULL,
                                             stderr=subprocess.PIPE, bufsize=0)
            except OSError as err:
                self.error = str(err)
                return
            self.started_at = time.time()
            threading.Thread(target=self._watch, args=(self.proc,), daemon=True).start()

    def stop(self):
        with self._lock:
            proc, self.proc = self.proc, None
            self.started_at = 0
        if proc and proc.poll() is None:
            proc.cs_stopping = True
            proc.terminate()               # ffmpeg closes the current segment cleanly
            try:
                proc.wait(timeout=8)
            except subprocess.TimeoutExpired:
                proc.kill()

    def rename(self, name):
        """Follow a camera being renamed, carrying its footage across."""
        wanted = slug(name)
        with self._lock:
            if wanted == self.folder_name:
                return
            running = self.is_running()
        if running:
            self.stop()
        old, new = self.folder, os.path.join(RECORD_DIR, wanted)
        try:
            if os.path.isdir(old) and not os.path.exists(new):
                os.rename(old, new)
        except OSError:
            pass                            # leave the old footage where it is
        self.folder_name = wanted
        if running:
            self._last_attempt = 0
            self.start()

    def _watch(self, proc):
        for line in iter(proc.stderr.readline, b""):
            text = line.decode("utf-8", "replace").strip()
            if not text or getattr(proc, "cs_stopping", False):
                continue
            if RtspCamera.is_noise(text):
                continue
            self.error = text
            sys.stderr.write("  [rec %s] %s\n" % (self.cam.name, text))
        code = proc.wait()
        if not getattr(proc, "cs_stopping", False) and code not in (0, None):
            sys.stderr.write("  [rec %s] recorder stopped (code %s); will retry\n"
                             % (self.cam.name, code))

    def status(self):
        return {"running": self.is_running(),
                "since": self.started_at or None,
                "folder": self.folder_name,
                "error": None if self.is_running() else self.error}


def recording_files():
    """Every stored segment, oldest first."""
    found = []
    for root, _dirs, names in os.walk(RECORD_DIR):
        for name in names:
            if not name.endswith(".mkv"):
                continue
            path = os.path.join(root, name)
            try:
                st = os.stat(path)
            except OSError:
                continue
            found.append({"path": path,
                          "folder": os.path.basename(root),
                          "name": name,
                          "size": st.st_size,
                          "mtime": st.st_mtime})
    found.sort(key=lambda f: f["mtime"])
    return found


def enforce_storage_limit(limit=None):
    """
    Delete the oldest footage until the total is back under the limit.

    The newest file in each camera's folder is left alone even if that means
    briefly exceeding the limit: it is the one being written to right now.
    """
    limit = STORAGE_LIMIT if limit is None else limit
    files = recording_files()
    total = sum(f["size"] for f in files)
    if total <= limit:
        return {"used": total, "deleted": 0, "freed": 0}

    newest_per_folder = {}
    for f in files:
        newest_per_folder[f["folder"]] = f["path"]      # sorted oldest first
    protected = set(newest_per_folder.values())

    deleted, freed = 0, 0
    for f in files:
        if total <= limit:
            break
        if f["path"] in protected:
            continue
        try:
            os.remove(f["path"])
        except OSError:
            continue
        total -= f["size"]
        freed += f["size"]
        deleted += 1
    return {"used": total, "deleted": deleted, "freed": freed}


def storage_summary():
    files = recording_files()
    folders = {}
    for f in files:
        entry = folders.setdefault(f["folder"], {"folder": f["folder"], "bytes": 0,
                                                 "segments": 0, "oldest": None,
                                                 "newest": None})
        entry["bytes"] += f["size"]
        entry["segments"] += 1
        entry["oldest"] = entry["oldest"] or f["mtime"]
        entry["newest"] = f["mtime"]
    photos = 0
    photo_count = 0
    try:
        for name in os.listdir(PHOTO_DIR):
            try:
                photos += os.path.getsize(os.path.join(PHOTO_DIR, name))
                photo_count += 1
            except OSError:
                pass
    except OSError:
        pass
    recent = [{"folder": f["folder"], "name": f["name"], "size": f["size"],
               "mtime": f["mtime"]} for f in files[-12:]][::-1]
    return {"limit": STORAGE_LIMIT,
            "used": sum(f["size"] for f in files),
            "segments": len(files),
            "photoBytes": photos,
            "photoCount": photo_count,
            "cameras": sorted(folders.values(), key=lambda d: -d["bytes"]),
            "recent": recent}


PHOTO_NAME = re.compile(r"^(\d{8})_(\d{6})_(.+?)(?:-(\d+))?\.(png|jpe?g)$", re.I)
SEGMENT_NAME = re.compile(r"^(\d{8})-(\d{6})\.mkv$")


def pretty_time(day, hhmmss):
    return "%s-%s-%s %s:%s:%s" % (day[0:4], day[4:6], day[6:8],
                                  hhmmss[0:2], hhmmss[2:4], hhmmss[4:6])


def files_being_written():
    """Segments an active recorder is writing into right now."""
    busy = set()
    by_folder = {}
    for f in recording_files():
        by_folder[f["folder"]] = f["path"]      # oldest first, so this ends newest
    for cam in CAMERAS:
        rec = getattr(cam, "recorder", None)
        if rec and rec.is_running():
            path = by_folder.get(rec.folder_name)
            if path:
                busy.add(path)
    return busy


def recording_entries():
    """Every stored segment, newest first, with the time taken from its name."""
    out = []
    live = files_being_written()
    for f in recording_files():
        m = SEGMENT_NAME.match(f["name"])
        day = m.group(1) if m else time.strftime("%Y%m%d", time.localtime(f["mtime"]))
        clock = m.group(2) if m else time.strftime("%H%M%S", time.localtime(f["mtime"]))
        out.append({"kind": "recording", "name": f["name"], "camera": f["folder"],
                    "day": day, "when": pretty_time(day, clock),
                    "size": f["size"], "mtime": f["mtime"],
                    # Still being written to. It can be downloaded, but it is
                    # only as complete as it was the moment you asked.
                    "live": f["path"] in live,
                    "url": "/recordings/%s/%s" % (quote(f["folder"]), quote(f["name"]))})
    out.reverse()
    return out


def photo_entries():
    """Photos, newest first. The camera and time come out of the filename."""
    out = []
    try:
        names = os.listdir(PHOTO_DIR)
    except OSError:
        return out
    for name in names:
        path = os.path.join(PHOTO_DIR, name)
        try:
            st = os.stat(path)
        except OSError:
            continue
        if not os.path.isfile(path):
            continue
        m = PHOTO_NAME.match(name)
        if m:
            day, clock, camera = m.group(1), m.group(2), m.group(3)
            when = pretty_time(day, clock)
        else:
            day = time.strftime("%Y%m%d", time.localtime(st.st_mtime))
            clock = time.strftime("%H%M%S", time.localtime(st.st_mtime))
            camera, when = "unknown", pretty_time(day, clock)
        out.append({"kind": "photo", "name": name, "camera": camera,
                    "day": day, "when": when, "size": st.st_size,
                    "mtime": st.st_mtime, "url": "/photos/" + quote(name)})
    out.sort(key=lambda e: (e["day"], e["name"]), reverse=True)
    return out


def browse(kind, camera=None, day=None, offset=0, limit=300):
    entries = photo_entries() if kind == "photos" else recording_entries()
    cameras = sorted({e["camera"] for e in entries})
    days = sorted({e["day"] for e in entries}, reverse=True)
    if camera:
        entries = [e for e in entries if e["camera"] == camera]
    if day:
        entries = [e for e in entries if e["day"] == day]
    total = len(entries)
    shown = entries[offset:offset + limit]
    return {"kind": kind, "cameras": cameras, "days": days,
            "total": total, "offset": offset,
            "bytes": sum(e["size"] for e in entries),
            "files": shown}


def delete_files(kind, names):
    """
    Remove stored files.

    Paths are rebuilt from the root rather than trusted, and the segment an
    active recorder is writing into is refused: deleting it would not stop the
    recording, it would just lose the footage being captured.
    """
    root = PHOTO_DIR if kind == "photos" else RECORD_DIR
    busy = files_being_written() if kind != "photos" else set()
    deleted, freed, skipped = 0, 0, []
    for rel in names:
        target = os.path.normpath(os.path.join(root, rel.lstrip("/")))
        if not target.startswith(os.path.normpath(root) + os.sep):
            skipped.append(rel)
            continue
        if target in busy:
            skipped.append(rel)
            continue
        try:
            size = os.path.getsize(target)
            os.remove(target)
        except OSError:
            skipped.append(rel)
            continue
        deleted += 1
        freed += size
    return {"deleted": deleted, "freed": freed, "skipped": skipped}


def supervise():
    """
    Keep active cameras recording and storage inside its limit.

    A camera that drops off the network takes its recorder down with it, so the
    recorders are restarted from here rather than only when something asks.
    """
    while True:
        try:
            for cam in list(CAMERAS):
                rec = getattr(cam, "recorder", None)
                if rec is None:
                    continue
                if getattr(cam, "active", False) and cam.available:
                    if not rec.is_running():
                        rec.start()
                elif rec.is_running():
                    rec.stop()
            enforce_storage_limit()
        except Exception as err:                     # never let the loop die
            sys.stderr.write("  supervisor: %s\n" % err)
        time.sleep(SWEEP_SECONDS)


# --------------------------------------------------------------------------
# http
# --------------------------------------------------------------------------

CAMERAS = []
LOCKED = False          # --lock-config disables editing


class Options:
    """Decoding settings applied to every RTSP camera."""
    rtsp_quality = 3
    rtsp_fps = None
    rtsp_size = None
    verbose = False


OPTS = Options()


def make_camera(cid, name, url, opts=None):
    # Read settings defensively: this is called with the parsed command line,
    # with OPTS, and from tests, and a missing field should fall back to the
    # default rather than stop a camera from being created at all.
    opts = opts or OPTS
    if url.startswith(("rtsp://", "rtsps://")):
        cam = RtspCamera(cid, name, url,
                         quality=getattr(opts, "rtsp_quality", 3),
                         fps=getattr(opts, "rtsp_fps", None),
                         size=getattr(opts, "rtsp_size", None),
                         verbose=getattr(opts, "verbose", False))
    else:
        cam = MjpegCamera(cid, name, url)
    cam.active = False
    cam.recorder = Recorder(cam)
    return cam


def apply_config(entries):
    """
    Swap in a new camera list without disturbing cameras that did not change.

    Rebuilding everything on every save would drop the picture on cameras the
    edit never touched, and restart an ffmpeg decode for no reason, so cameras
    whose address is unchanged are carried over as they are.
    """
    previous = {c.id: c for c in CAMERAS}
    rebuilt, kept = [], set()
    for entry in entries:
        cid = entry.get("id") or new_id()
        name = entry["name"]
        url = entry["url"]
        old = previous.get(cid)
        # MjpegCamera stores its address with any trailing slash removed, so
        # compare against both spellings before deciding it has changed.
        unchanged = old is not None and getattr(old, "url", None) in (url, url.rstrip("/"))
        if unchanged:
            cam = old
            if cam.name != name:
                cam.name = name
                cam.recorder.rename(name)   # take the footage folder with it
        else:
            cam = make_camera(cid, name, url)
        cam.active = bool(entry.get("active"))
        rebuilt.append(cam)
        kept.add(id(cam))

    for cam in CAMERAS:
        if id(cam) in kept:
            continue
        if getattr(cam, "recorder", None):
            cam.recorder.stop()      # dropped from the config, so stop recording it
        if isinstance(cam, RtspCamera):
            cam.shutdown()           # released, so stop decoding it

    CAMERAS[:] = rebuilt
    return CAMERAS


def config_entries():
    """The current cameras, safe to hand to the config page."""
    return [dict(recording_state(c), id=c.id, name=c.name, url=redact_url(c.url))
            for c in CAMERAS]


def persist():
    """Write the current cameras back to disk, keeping real passwords."""
    save_config([{"id": c.id, "name": c.name, "url": c.url,
                  "active": bool(getattr(c, "active", False))} for c in CAMERAS])


def probe(url, timeout=15):
    """
    Try to pull a single frame, so a camera can be checked before it is saved.
    """
    url = (url or "").strip()
    if not valid_url(url):
        return {"ok": False, "message": "Address must start with http:// or rtsp://"}

    if url.startswith(("rtsp://", "rtsps://")):
        if not ffmpeg_available():
            return {"ok": False, "kind": "rtsp",
                    "message": "ffmpeg is not installed, so RTSP cameras cannot be used."}
        args = ["ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error",
                ffmpeg_timeout_flag(), str(int(timeout * 1000000)),
                "-rtsp_transport", "tcp", "-i", url,
                "-frames:v", "1", "-f", "mjpeg", "-q:v", "3", "-"]
        try:
            done = subprocess.run(args, capture_output=True, timeout=timeout + 5)
        except subprocess.TimeoutExpired:
            return {"ok": False, "kind": "rtsp",
                    "message": "No response within %ds." % timeout}
        if done.stdout[:3] == b"\xff\xd8\xff":
            size = jpeg_size(done.stdout)
            return {"ok": True, "kind": "rtsp",
                    "width": size[0] if size else None,
                    "height": size[1] if size else None}
        err = [l for l in done.stderr.decode("utf-8", "replace").splitlines()
               if l.strip() and not RtspCamera.is_noise(l)]
        return {"ok": False, "kind": "rtsp",
                "message": err[-1] if err else "No picture came back."}

    base = url.rstrip("/")
    for candidate in (base + "/?action=snapshot", base):
        try:
            with urlopen(candidate, timeout=timeout) as r:
                head = r.read(600000)
        except (URLError, HTTPError, socket.timeout, OSError) as err:
            message = str(getattr(err, "reason", err))
            continue
        start = head.find(b"\xff\xd8\xff")
        if start >= 0:
            size = jpeg_size(head[start:])
            return {"ok": True, "kind": "mjpeg",
                    "width": size[0] if size else None,
                    "height": size[1] if size else None}
        message = "Reachable, but no JPEG was found in the reply."
    return {"ok": False, "kind": "mjpeg", "message": message}


def find_camera(cid):
    for cam in CAMERAS:
        if cam.id == cid:
            return cam
    return None


class Station(ThreadingHTTPServer):
    """
    A threading server that stays quiet about viewers leaving.

    Long-lived MJPEG responses are aborted every time someone switches camera,
    reloads, or closes a tab. That is routine, not a fault, so it should not
    print a stack trace. Anything else still gets reported normally.
    """

    daemon_threads = True
    allow_reuse_address = True

    def handle_error(self, request, client_address):
        if isinstance(sys.exc_info()[1], (ConnectionError, socket.timeout)):
            return
        super().handle_error(request, client_address)


class Handler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"
    server_version = "CameraStation/2.0"

    def do_GET(self):
        parsed = urlparse(self.path)
        path = parsed.path
        query = parse_qs(parsed.query)

        if path in ("/", "/index.html"):
            self.serve_page()
            return
        if path == "/cameras":
            self.serve_json([c.describe() for c in CAMERAS])
            return
        if path in ("/config", "/config.html"):
            self.serve_file(CONFIG_PAGE, "text/html; charset=utf-8")
            return
        if path == "/api/config":
            self.serve_json({"cameras": config_entries(), "locked": LOCKED,
                             "ffmpeg": ffmpeg_available()})
            return
        if path == "/api/storage":
            self.serve_json(storage_summary())
            return
        if path in ("/files", "/library", "/files.html"):
            self.serve_file(LIBRARY_PAGE, "text/html; charset=utf-8")
            return
        if path == "/api/files":
            kind = (query.get("kind") or ["recordings"])[0]
            kind = "photos" if kind == "photos" else "recordings"
            def one(key):
                value = (query.get(key) or [""])[0].strip()
                return value or None
            try:
                offset = max(0, int((query.get("offset") or ["0"])[0]))
            except ValueError:
                offset = 0
            result = browse(kind, one("camera"), one("day"), offset)
            result["limit"] = STORAGE_LIMIT
            result["used"] = sum(f["size"] for f in recording_files())
            self.serve_json(result)
            return
        if path.startswith("/recordings/") or path.startswith("/photos/"):
            self.serve_stored(path, (query.get("download") or [""])[0] == "1")
            return

        if path in ("/stream", "/snapshot"):
            cid = (query.get("cam") or [None])[0]
            cam = find_camera(cid) if cid else (CAMERAS[0] if CAMERAS else None)
            if cam is None:
                self.fail(404, "No camera named %s" % cid)
                return
            if path == "/stream":
                self.serve_stream(cam)
            else:
                self.serve_snapshot(cam)
            return

        self.fail(404, "Nothing is served at %s" % path)

    def do_POST(self):
        parsed = urlparse(self.path)
        path = parsed.path
        try:
            length = int(self.headers.get("Content-Length") or 0)
        except ValueError:
            length = 0

        if path == "/api/photo":
            self.save_photo(parse_qs(parsed.query), length)
            return
        if length > 1000000:
            self.fail(413, "That is too much data.")
            return
        try:
            payload = json.loads(self.rfile.read(length) or b"{}")
        except ValueError:
            self.fail(400, "Could not read that as JSON.")
            return

        if path == "/api/test":
            self.serve_json(probe(payload.get("url", "")))
            return

        if path == "/api/active":
            cam = find_camera(str(payload.get("id") or ""))
            if cam is None:
                self.fail(404, "No such camera.")
                return
            if LOCKED:
                self.fail(403, "Recording cannot be changed while --lock-config is set.")
                return
            cam.active = bool(payload.get("active"))
            if cam.active:
                cam.recorder.start()
            else:
                cam.recorder.stop()
            try:
                persist()
            except OSError as err:
                self.fail(500, "Could not save that (%s)" % err)
                return
            self.serve_json(dict(recording_state(cam), id=cam.id))
            return

        if path == "/api/delete":
            if LOCKED:
                self.fail(403, "Files cannot be deleted while --lock-config is set.")
                return
            kind = "photos" if payload.get("kind") == "photos" else "recordings"
            names = payload.get("names")
            if not isinstance(names, list) or not names:
                self.fail(400, "Nothing was selected.")
                return
            if len(names) > 5000:
                self.fail(400, "That is too many files at once.")
                return
            self.serve_json(delete_files(kind, [str(n) for n in names]))
            return

        if path == "/api/config":
            if LOCKED:
                self.fail(403, "Editing is disabled because the server was "
                               "started with --lock-config.")
                return
            self.save_cameras(payload)
            return

        self.fail(404, "Nothing accepts a POST at %s" % path)

    def save_photo(self, query, length):
        """
        Store a picture taken in the page.

        The browser sends the image rather than the server grabbing its own,
        because the page may be zoomed in: what gets saved is the exact framing
        on screen, cut from the original pixels.
        """
        if length <= 0 or length > 80 * 1024 * 1024:
            self.fail(400, "No image, or one too large to be a photo.")
            return
        cam = find_camera((query.get("cam") or [""])[0])
        if cam is None:
            self.fail(404, "No such camera.")
            return
        ctype = (self.headers.get("Content-Type") or "").lower()
        ext = "jpg" if "jpeg" in ctype else "png"
        body = self.rfile.read(length)
        if not (body[:3] == b"\xff\xd8\xff" or body[:8] == b"\x89PNG\r\n\x1a\n"):
            self.fail(400, "That did not arrive as a PNG or JPEG.")
            return

        ensure_dirs()
        stamp = time.strftime("%Y%m%d_%H%M%S")
        name = "%s_%s.%s" % (stamp, slug(cam.name), ext)
        target = os.path.join(PHOTO_DIR, name)
        # Two photos inside one second should not overwrite each other.
        n = 2
        while os.path.exists(target):
            name = "%s_%s-%d.%s" % (stamp, slug(cam.name), n, ext)
            target = os.path.join(PHOTO_DIR, name)
            n += 1
        try:
            with open(target, "wb") as fh:
                fh.write(body)
        except OSError as err:
            self.fail(500, "Could not save the photo (%s)" % err)
            return
        self.serve_json({"ok": True, "name": name,
                         "url": "/photos/" + quote(name), "bytes": len(body)})

    def save_cameras(self, payload):
        incoming = payload.get("cameras")
        if not isinstance(incoming, list):
            self.fail(400, "Expected a list of cameras.")
            return

        known = {c.id: c.url for c in CAMERAS}
        entries, seen = [], set()
        for i, item in enumerate(incoming):
            if not isinstance(item, dict):
                self.fail(400, "Camera %d is not readable." % (i + 1))
                return
            name = str(item.get("name") or "").strip() or "Camera %d" % (i + 1)
            url = str(item.get("url") or "").strip()
            cid = str(item.get("id") or "").strip() or new_id()
            # The page never receives passwords, so bullets left in place mean
            # "keep the one you already have".
            url = restore_url(url, known.get(cid))
            if not valid_url(url):
                self.fail(400, "%s needs an address starting http:// or rtsp://" % name)
                return
            if cid in seen:
                cid = new_id()
            seen.add(cid)
            entries.append({"id": cid, "name": name, "url": url,
                            "active": bool(item.get("active"))})

        try:
            save_config(entries)
        except OSError as err:
            self.fail(500, "Could not write cameras.json (%s)" % err)
            return

        apply_config(entries)
        self.serve_json({"ok": True, "cameras": config_entries()})

    def do_HEAD(self):
        if urlparse(self.path).path in ("/", "/index.html"):
            self.send_response(200)
            self.send_header("Content-Type", "text/html; charset=utf-8")
            self.send_header("Content-Length", "0")
            self.end_headers()
        else:
            self.fail(404, "Nothing is served here")

    # ---- handlers ----

    def serve_page(self):
        self.serve_file(PAGE, "text/html; charset=utf-8")

    def serve_file(self, path, ctype):
        try:
            with open(path, "rb") as fh:
                body = fh.read()
        except OSError:
            self.fail(500, "%s is missing. Keep it next to server.py."
                      % os.path.basename(path))
            return
        self.send_response(200)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        self.wfile.write(body)

    def serve_stored(self, path, force_download=False):
        """Serve a recording or photo, refusing anything outside the data folder."""
        root = RECORD_DIR if path.startswith("/recordings/") else PHOTO_DIR
        rel = path.split("/", 2)[2] if path.count("/") >= 2 else ""
        target = os.path.normpath(os.path.join(root, unquote(rel)))
        if not target.startswith(os.path.normpath(root) + os.sep):
            self.fail(403, "That is not inside the recordings folder.")
            return
        if not os.path.isfile(target):
            self.fail(404, "No such file.")
            return
        ctype = ("video/x-matroska" if target.endswith(".mkv")
                 else "image/png" if target.endswith(".png")
                 else "image/jpeg" if target.endswith((".jpg", ".jpeg"))
                 else "application/octet-stream")
        try:
            size = os.path.getsize(target)
            self.send_response(200)
            self.send_header("Content-Type", ctype)
            self.send_header("Content-Length", str(size))
            # Served inline so a photo can simply be looked at. Saving is driven
            # by the link instead, or by asking for it explicitly; forcing every
            # request to be a download would stop thumbnails rendering at all.
            if force_download:
                self.send_header("Content-Disposition",
                                 'attachment; filename="%s"' % os.path.basename(target))
            self.end_headers()
            with open(target, "rb") as fh:
                while True:
                    chunk = fh.read(65536)
                    if not chunk:
                        break
                    self.wfile.write(chunk)
        except ConnectionError:
            pass
        except OSError as err:
            self.fail(500, "Could not read that file (%s)" % err)

    def serve_json(self, obj):
        body = json.dumps(obj).encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        self.wfile.write(body)

    def serve_stream(self, cam):
        if not cam.available:
            self.fail(503, cam.reason or "This camera is unavailable.")
            return
        if cam.kind == "mjpeg":
            self.relay_mjpeg(cam)
        else:
            self.relay_frames(cam)

    def relay_mjpeg(self, cam):
        """Straight passthrough: the camera's own JPEG bytes, untouched."""
        try:
            upstream = cam.open_upstream("stream")
        except (URLError, HTTPError, socket.timeout) as err:
            self.fail(502, "Cannot reach %s at %s (%s)" % (cam.name, safe_host(cam.url), err))
            return

        ctype = upstream.headers.get(
            "Content-Type", "multipart/x-mixed-replace; boundary=boundarydonotcross")
        self.send_response(200)
        self.send_header("Content-Type", ctype)
        self.send_header("Cache-Control", "no-store, no-cache")
        self.send_header("Pragma", "no-cache")
        self.send_header("Connection", "close")
        self.end_headers()
        self.close_connection = True

        try:
            while True:
                chunk = upstream.read(8192)
                if not chunk:
                    break
                self.wfile.write(chunk)
        except ConnectionError:
            # The viewer closed the tab, switched camera, or reloaded. Windows
            # reports this as ConnectionAbortedError and Unix as BrokenPipeError,
            # so catch the shared base class rather than one platform's spelling.
            pass
        finally:
            upstream.close()

    def relay_frames(self, cam):
        """Re-publish decoded frames as multipart JPEG."""
        q = cam.subscribe()
        self.send_response(200)
        self.send_header("Content-Type",
                         "multipart/x-mixed-replace; boundary=%s" % BOUNDARY)
        self.send_header("Cache-Control", "no-store, no-cache")
        self.send_header("Pragma", "no-cache")
        self.send_header("Connection", "close")
        self.end_headers()
        self.close_connection = True

        head = ("--%s\r\nContent-Type: image/jpeg\r\nContent-Length: " % BOUNDARY).encode()
        try:
            while True:
                try:
                    frame = q.get(timeout=15)
                except Empty:
                    break     # nothing arriving; let the page reconnect
                self.wfile.write(head + str(len(frame)).encode() + b"\r\n\r\n")
                self.wfile.write(frame)
                self.wfile.write(b"\r\n")
        except ConnectionError:
            pass          # viewer went away; unsubscribing below frees ffmpeg
        finally:
            cam.unsubscribe(q)

    def serve_snapshot(self, cam):
        if not cam.available:
            self.fail(503, cam.reason or "This camera is unavailable.")
            return
        if cam.kind == "mjpeg":
            try:
                upstream = cam.open_upstream("snapshot")
                body = upstream.read()
                ctype = upstream.headers.get("Content-Type", "image/jpeg")
                upstream.close()
            except (URLError, HTTPError, socket.timeout) as err:
                self.fail(502, "Cannot reach %s at %s (%s)" % (cam.name, safe_host(cam.url), err))
                return
        else:
            body = cam.snapshot()
            ctype = "image/jpeg"
            if not body:
                self.fail(502, "No picture yet from %s. %s"
                          % (cam.name, cam.describe().get("reason") or ""))
                return

        self.send_response(200)
        self.send_header("Content-Type", ctype)
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Cache-Control", "no-store")
        self.end_headers()
        self.wfile.write(body)

    # ---- helpers ----

    def fail(self, code, message):
        body = message.encode("utf-8")
        self.send_response(code)
        self.send_header("Content-Type", "text/plain; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        try:
            self.wfile.write(body)
        except ConnectionError:
            pass

    def log_message(self, fmt, *args):
        try:
            line = fmt % args
        except (TypeError, ValueError):
            line = fmt
        if "/stream" in line:
            return
        sys.stderr.write("  %s\n" % line)


# --------------------------------------------------------------------------
# startup
# --------------------------------------------------------------------------

def build_camera(index, name, url, args):
    return make_camera("cam%d" % (index + 1), name, url, args)


def lan_address():
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        sock.connect(("192.0.2.1", 1))  # never actually sends anything
        return sock.getsockname()[0]
    except OSError:
        return "127.0.0.1"
    finally:
        sock.close()


def main():
    parser = argparse.ArgumentParser(
        description="Serve a viewer/recorder page for MJPEG and RTSP cameras.")
    parser.add_argument("--camera", action="append", default=[], metavar="NAME=URL",
                        help="Add a camera. Repeatable. RTSP URLs are decoded with ffmpeg.")
    parser.add_argument("--source", help="Shorthand for a single MJPEG camera.")
    parser.add_argument("--port", type=int, default=8000, help="Port to listen on")
    parser.add_argument("--host", default="0.0.0.0",
                        help="Address to bind. Use 127.0.0.1 to keep it on this machine only.")
    parser.add_argument("--rtsp-quality", type=int, default=3, metavar="1-31",
                        help="JPEG quality for RTSP cameras, 1 is best (default: %(default)s)")
    parser.add_argument("--rtsp-fps", type=float, default=None,
                        help="Cap the frame rate of RTSP cameras to save CPU")
    parser.add_argument("--rtsp-size", default=None, metavar="WxH",
                        help="Scale RTSP cameras down, e.g. 1280x720, to save CPU")
    parser.add_argument("--verbose", action="store_true",
                        help="Show all ffmpeg output, including routine decoder chatter")
    parser.add_argument("--lock-config", action="store_true",
                        help="Serve the cameras read-only; the config page cannot save")
    parser.add_argument("--data-dir", default=None,
                        help="Where recordings, photos and cameras.json live "
                             "(default: ./data, or $CAMERA_STATION_DATA)")
    parser.add_argument("--storage-limit", default=None, metavar="GB",
                        help="Total footage to keep before deleting the oldest "
                             "(default: 10)")
    parser.add_argument("--segment-minutes", type=float, default=None,
                        help="Length of each recording file (default: 10)")
    args = parser.parse_args()

    global LOCKED, DATA_DIR, CONFIG_FILE, RECORD_DIR, PHOTO_DIR
    global STORAGE_LIMIT, SEGMENT_SECONDS
    LOCKED = args.lock_config

    if args.data_dir:
        DATA_DIR = os.path.abspath(args.data_dir)
        CONFIG_FILE = os.path.join(DATA_DIR, "cameras.json")
        RECORD_DIR = os.path.join(DATA_DIR, "recordings")
        PHOTO_DIR = os.path.join(DATA_DIR, "photos")
    if args.storage_limit:
        try:
            STORAGE_LIMIT = int(float(args.storage_limit) * 1024 ** 3)
        except ValueError:
            parser.error("--storage-limit takes a number of gigabytes")
    if args.segment_minutes:
        SEGMENT_SECONDS = max(10, int(args.segment_minutes * 60))
    ensure_dirs()
    OPTS.rtsp_quality = args.rtsp_quality
    OPTS.rtsp_fps = args.rtsp_fps
    OPTS.rtsp_size = args.rtsp_size
    OPTS.verbose = args.verbose

    specs = []
    if args.source:
        specs.append(("Camera 1", args.source))
    for entry in args.camera:
        name, sep, url = entry.partition("=")
        if not sep:
            name, url = "Camera %d" % (len(specs) + 1), entry
        specs.append((name.strip(), url.strip()))
    if specs:
        # Cameras named on the command line win for this run and are not saved.
        entries = [{"id": "cam%d" % (i + 1), "name": n, "url": u}
                   for i, (n, u) in enumerate(specs)]
        source = "command line"
    else:
        entries = load_config()
        source = "cameras.json"
        if entries is None:
            entries = [{"id": "cam%d" % (i + 1), "name": n, "url": u}
                       for i, (n, u) in enumerate(DEFAULT_CAMERAS)]
            source = "defaults"

    apply_config(entries)
    threading.Thread(target=supervise, daemon=True).start()

    httpd = Station((args.host, args.port), Handler)

    shown = "localhost" if args.host in ("0.0.0.0", "127.0.0.1") else args.host
    print("\n  Camera Station")
    for cam in CAMERAS:
        note = "" if cam.available else "  (%s)" % cam.reason
        mark = "REC " if getattr(cam, "active", False) else "    "
        print("  %s %-6s %-6s %s%s" % (mark, cam.id, cam.kind, safe_host(cam.url), note))
    print("  from   %s" % source)
    print("  data   %s" % DATA_DIR)
    print("  keeps  %.0f GB of footage, oldest deleted first"
          % (STORAGE_LIMIT / 1024 ** 3))
    print("  open   http://%s:%d" % (shown, args.port))
    print("  set up http://%s:%d/config%s"
          % (shown, args.port, "  (locked)" if LOCKED else ""))
    print("  files  http://%s:%d/files" % (shown, args.port))
    if args.host == "0.0.0.0":
        print("  on LAN http://%s:%d" % (lan_address(), args.port))
    print("  Ctrl+C to stop\n")

    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        print("\n  Stopping.")
        for cam in CAMERAS:
            if getattr(cam, "recorder", None):
                cam.recorder.stop()      # closes the segment being written
            if isinstance(cam, RtspCamera):
                cam._stop_if_idle()
        httpd.server_close()
        print("  Stopped.\n")


if __name__ == "__main__":
    main()