Files
simply-dvb/README.pl.md
T
Mateusz Gruszczyński c30064b531
build / test (push) Canceled after 0s
build / deb (amd64) (push) Canceled after 0s
build / deb (arm64) (push) Canceled after 0s
build / deb (armhf) (push) Canceled after 0s
first commit
2026-11-16 16:19:21 +01:00

311 lines
22 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# simply-dvb
[English](README.md) · dokumentacja główna jest po angielsku; to jest wersja polska.
> Wcześniej: *simple-dvbt*. Nazwa zmieniona, bo projekt obsługuje nie tylko DVB-T (także DVB-T2 i DVB-C).
> Przejście ze starej instalacji: `sudo systemctl disable --now simple-dvbt && sudo apt remove simple-dvbt`,
> zainstaluj `simply-dvb`, zatrzymaj go i skopiuj dane: `sudo cp -a /var/lib/simple-dvbt/. /var/lib/simply-dvb/ && sudo chown -R simply-dvb: /var/lib/simply-dvb`.
> Baza `simple-dvbt.db` zostanie przejęta automatycznie, identyfikatory kanałów (UUID) się nie zmieniają.
Lekki serwer telewizji **DVB-T / DVB-T2 / DVB-C** napisany w Rust – prosta alternatywa dla tvheadend,
**zgodna z jego adresami HTTP** (można go podmienić 1:1 w aplikacjach): skanuje multipleksy, udostępnia kanały jako **HLS**, **MPEG-TS** i playlistę **M3U**,
zbiera **EPG** z sygnału i publikuje je jako **XMLTV**, **nagrywa** na dysk i ma szybki panel WWW
z odtwarzaczem w przeglądarce. Jeden plik binarny, bez zależności w czasie działania
(ffmpeg jest opcjonalny – tylko do transkodowania dla przeglądarek).
Testowany z kartami na **Silicon Labs Si2168** (DVB-T/T2/C) + tuner Si2157.
![Przegląd](docs/images/overview.png)
| Telewizja | Program TV |
|---|---|
| ![Telewizja](docs/images/tv.png) | ![EPG](docs/images/epg.png) |
| ![Kanały](docs/images/channels.png) | ![Tunery](docs/images/tuners.png) |
## Możliwości
| Obszar | Co jest |
|---|---|
| Tunery | Natywne Linux DVB API v5 (ioctl, bez `dvbv5-zap`/`w_scan`), wiele adapterów, siła sygnału (dBm/%), SNR (dB), licznik błędów, współdzielenie multipleksu przez wielu klientów, priorytety (nagrania > oglądanie > EPG w tle), adapter wirtualny z plików `.ts` |
| Skanowanie | DVB-T, DVB-T2 (PLP), DVB-C (symbol rate, QAM). Listy: Europa UHF 21–48 (po refarmingu 700 MHz) i 21–69, VHF III + UHF, Włochy, Australia (7 MHz), Nowa Zelandia, kablówka 114–858 MHz, własna lista, ponowne skanowanie zapisanych. **Odkrywanie przez NIT** (multipleksy ogłaszane przez sieć dopisywane do kolejki), LCN, automatyczne tworzenie kanałów, **skanowanie w tle** zapisanych multipleksów na wolnym adapterze (domyślnie co 24 h; ustępuje od razu, gdy ktoś zaczyna oglądać lub nagrywać); teksty DVB we wszystkich tablicach znaków (ISO 6937, ISO 8859-1…16, UTF-8, UCS-2, GB2312, Big5) |
| Kanały | Lista z przeciąganiem (kolejność), numeracja, grupy, włącz/wyłącz, ikony (automatyczne wyszukiwanie w tle, wgrywanie, URL), ręczne powiązanie z usługą; filtry (typ, grupa, włączone, ukryj kodowane/uszkodzone, bez ikony/EPG) i zbiorcze włącz/wyłącz/usuń przefiltrowanej listy |
| Strumienie | HLS live (segmentacja na klatkach kluczowych, H.264/HEVC/MPEG-2), ciągły MPEG-TS (start od klatki kluczowej), profile ffmpeg: `pass` (oryginał), `aac` (audio → AAC), `h264` (HEVC/MPEG-2 → H.264 720p) |
| M3U / XMLTV | `/playlist.m3u` z `tvg-id`, `tvg-chno`, `tvg-logo`, `group-title`, `url-tvg`; `/epg.xml`; **ścieżki tvheadend**: `/playlist`, `/stream/channelid/<id>`, `/xmltv/channels`, `/imagecache/<id>` |
| Porty | Panel/API na **9980**, osobny port strumieni **9981**, **HTSP na 9982** (jak HTTP tvheadend, bez panelu – można go wystawić na zewnątrz) |
| EPG | Z eteru (EIT p/f + harmonogram, także z innych multipleksów), okresowe przechodzenie po multipleksach, **import XMLTV z linku** (np. `https://epg.ovh/pl.xml`, `.xml`/`.xml.gz`), dopasowanie kanałów po ID lub nazwie, podpowiedzi identyfikatorów z zaimportowanych źródeł |
| Przeglądarka | Odtwarzacz hls.js, automatyczny dobór profilu wg kodeków obsługiwanych przez przeglądarkę (HEVC, AC-3, MP2…) z przełączaniem w razie błędu, siatka EPG, nagrywanie jednym kliknięciem |
| Udostępnianie | Publiczny link do pojedynczego kanału (`/watch/<token>`) – strona z odtwarzaczem, bez dostępu do innych kanałów |
| Bezpieczeństwo | Logowanie do panelu (argon2, sesje HttpOnly, ochrona CSRF, limit prób), role *administrator* / *widz*, ACL: sieci z dostępem do strumieni bez tokenu, sieci z dostępem do panelu, tokeny dostępu (z opcjonalnym ograniczeniem do sieci), zaufane reverse proxy. Wpisy ACL mogą być sieciami, adresami lub **nazwami hostów DDNS** (dla zmiennego publicznego IP; odświeżane co minutę) |
| Nagrywanie | Z EPG (z marginesami) lub ręcznie; **reguły seryjne** (fragment tytułu lub regex, opcjonalnie kanał – jak autorec w tvheadend) z podglądem pasujących audycji; plik `.ts` + indeks, odtwarzanie w przeglądarce (HLS VOD z byte-range), pobieranie, wznowienie po restarcie; automatyczne porządkowanie (wiek, minimalne wolne miejsce) |
| Odtwarzacz | Skróty klawiszowe: ↑/↓ zmiana kanału, cyfry – numer kanału, F – pełny ekran, P – obraz w obrazie, M – wycisz, spacja – pauza, ? – pomoc; OSD z numerem i nazwą kanału |
| Logi | Zakładka *Logi* z kategoriami (aplikacja, tunery i urządzenia, strumieniowanie, dostęp, EPG, nagrywanie, system), filtrem poziomu, wyszukiwaniem, śledzeniem na żywo i pobieraniem; logowania, odrzucone żądania, tokeny i sesje HTSP trafiają do kategorii *dostęp*. Aktywni klienci: protokół, urządzenie (z User-Agent / nazwy klienta HTSP), adres, dostęp, czas, przepływność; harmonogram nagrań z wykrywaniem konfliktów tunerów |
| Monitoring | Wykresy na żywo w przeglądzie (historia 15 min): CPU (system i proces), pamięć, RSS procesu, przepustowość strumieni, sieć, klienci/sesje HLS, temperatura, obciążenie; dla tunera: przepływność, siła sygnału (%/dBm), SNR, bloki z błędami. `/metrics` w formacie Prometheus |
| Kopia zapasowa | Eksport/import konfiguracji (multipleksy, usługi, kanały, reguły, tokeny, ustawienia) jako JSON |
| Interfejs | Angielski (domyślnie) i polski, **dowolna liczba języków** (pliki `langs/<locale>.json` – każdy plik pojawia się po zbudowaniu w liście wyboru języka); odtwarzanie w przeglądarce lub **VLC** (playlista jednego kanału); motywy: ciemny (domyślny), północ (OLED), jasny, systemowy; 7 kolorów akcentu, gęstość, skala, przypięty pasek boczny, strona startowa, domyślny profil odtwarzacza, powiększenie siatki EPG, zegar, logotypy/postęp audycji, animacje – zapisywane w przeglądarce (*Ustawienia → Wygląd*) |
| Dystrybucja | Paczka `.deb` z usługą systemd (utwardzoną), obraz Docker, `compose.yml` |
## Szybki start
### Paczka .deb (Debian / Ubuntu / Raspberry Pi OS)
Osobne skrypty dla każdej architektury (do użycia także w CI):
```bash
scripts/build-deb-amd64.sh # x86_64 (PC, serwer, NAS) -> dist/simply-dvb_<wersja>-1_amd64.deb
scripts/build-deb-arm64.sh # Raspberry Pi 3/4/5, 64-bit OS -> dist/simply-dvb_<wersja>-1_arm64.deb
scripts/build-deb-armhf.sh # Raspberry Pi, 32-bit RPi OS -> dist/simply-dvb_<wersja>-1_armhf.deb
scripts/build-deb-all.sh # wszystkie trzy
```
Wszystkie wywołują `scripts/build-deb.sh <arch>`. **Sama budowa odbywa się w kontenerze Docker**
(obraz `scripts/docker/builder.Dockerfile`: Rust + targety, zig, cargo-zigbuild, cargo-deb), więc na hoście
potrzebny jest tylko Docker. Obraz budujący tworzy się automatycznie przy pierwszym uruchomieniu
(później z cache); crates i kompilacja są trzymane w `.cache/` i `target/docker/`, a gotowe paczki trafiają do
`dist/` z uprawnieniami bieżącego użytkownika. Kompilacja skrośna przez zig daje stałą bazę glibc 2.31,
więc paczki działają na Debianie 11+, Ubuntu 20.04+ i RPi OS bullseye+.
Zmienne: `BUILD_IN_DOCKER=0` (budowa bezpośrednio na hoście/w CI – wtedy potrzebne narzędzia jak
w obrazie budującym), `BUILDER_IMAGE`, `DOCKER_ARGS`, `DOCKER_BUILD_ARGS` (np. `--network host` za proxy),
`GLIBC` (domyślnie 2.31), `OUT_DIR` (domyślnie `dist`).
Instalacja:
```bash
sudo apt install ./dist/simply-dvb_*_$(dpkg --print-architecture).deb
sudo cat /var/lib/simply-dvb/initial-admin-password.txt
```
Panel: `http://<serwer>:9980/`, strumienie: `http://<serwer>:9981/playlist`. Konfiguracja usługi: `/etc/default/simply-dvb`,
logi: `journalctl -u simply-dvb -f`. Użytkownik `simply-dvb` jest dodawany do grupy `video`.
### Docker
Obraz buduje się natywnie na x86_64 i ARM (także `docker buildx build --platform linux/amd64,linux/arm64 .`).
```bash
docker compose up -d --build # compose.yml: /dev/dvb, grupa video, sieć hosta
docker logs simply-dvb | grep hasłem
```
Grupa `video` musi mieć ten sam GID co na hoście: `VIDEO_GID=$(getent group video | cut -d: -f3) docker compose up -d`.
### Ze źródeł
```bash
cargo build --release
./target/release/simply-dvb --data-dir ./data serve --listen 0.0.0.0:9980 --stream-listen 0.0.0.0:9981
```
Bez karty DVB (demo, testy interfejsu):
```bash
./dev.sh demo # generuje 2 multipleksy z obrazem testowym i EPG, uruchamia adapter wirtualny
```
## Pierwsze kroki
1. **Tunery** → sprawdź, czy karta jest widoczna (np. *Silicon Labs Si2168*, DVB-T / DVB-T2).
2. **Skanowanie** → lista dla Twojego regionu (np. „Europa – UHF 21–48”) → *Rozpocznij skanowanie*. Kanały tworzą się automatycznie (numery LCN).
3. **Kanały** → ułóż kolejność przeciąganiem, „Szukaj ikon”.
4. **Dostęp** → skopiuj adres M3U i EPG do aplikacji IPTV w telewizorze.
5. **Telewizja** → oglądanie w przeglądarce.
### Telewizor (np. Sony / Android TV)
W aplikacji IPTV (np. *Kodi + PVR IPTV Simple Client*, *TiviMate*, *IPTV Smarters*, *OTT Navigator*):
* playlista: `http://<serwer>:9981/playlist` (format tvheadend) albo `http://<serwer>:9981/playlist.m3u` (`?format=hls` dla HLS),
* EPG: `http://<serwer>:9981/xmltv/channels` (lub `/epg.xml`).
W sieci lokalnej token nie jest potrzebny (domyślnie otwarte są sieci prywatne – zmienisz w *Dostęp → ACL*).
Spoza LAN utwórz token i użyj `…/playlist.m3u?token=<token>` – token jest automatycznie doklejany do
wszystkich adresów w playliście i EPG.
## Zgodność z tvheadend i porty
simply-dvb odtwarza **interfejs HTTP tvheadend**, z którego korzystają aplikacje IPTV, Kodi (IPTV Simple),
VLC i telewizory. Po zeskanowaniu i ułożeniu listy wystarczy w aplikacji zmienić tylko adres serwera:
| tvheadend | simply-dvb | Uwagi |
|---|---|---|
| `http://host:9981/playlist` (`/playlist/channels`, `.m3u`, `/playlist/auth/channels`) | to samo, linia w linię | `#EXTINF:-1 tvg-logo=… tvg-id=<uuid> tvg-chno=…,Nazwa` |
| `/stream/channelid/<id>`, `/stream/channelnumber/<n>`, `/stream/channelname/<nazwa>`, `/stream/channel/<uuid>` | to samo | ciągły MPEG-TS |
| `/playlist/channelid/<id>` | to samo | playlista jednego kanału – np. „Otwórz w VLC” |
| `/xmltv`, `/xmltv/channels` | to samo | identyfikatory kanałów = `tvg-id` z playlisty |
| `/imagecache/<id>` | to samo | logo kanału |
| JSON API `/api/serverinfo`, `/api/channel/grid`, `/api/channeltag/grid`, `/api/epg/events/grid`, `/api/dvr/entry/*`, `/dvrfile/<uuid>` | to samo (na porcie strumieni) | używa go PVR Live, Sparkle TV i inne źródła „Kanały na żywo” w Android TV |
| `?auth=<kod>`, `?ticket=<bilet>`, HTTP Basic (login/hasło) | token dostępu jako `auth`/`ticket`; Basic: login i hasło użytkownika panelu albo token jako hasło | |
| `?profile=pass`, `webtv-h264-aac-mpegts` … | `pass`; profile webtv → `h264`; nieznane → `pass` | |
| port 9981 (HTTP) | **9981 – osobny port strumieni** (bez panelu i API) | panel na **9980** |
| port 9982 (HTSP) | **9982 – serwer HTSP** | Kodi „Tvheadend HTSP Client”, TVHClient, aplikacje PVR |
Warto wiedzieć:
* **HTSP (9982)** – binarny protokół tvheadend. Używają go aplikacje, w których podaje się adres serwera i port 9981,
a obraz idzie przez 9982 (Kodi „Tvheadend HTSP Client”, TVHClient, aplikacje PVR na Android/Google/Sony TV).
Obsługiwane: kanały i tagi, EPG (aktualizacje na żywo, wyszukiwanie), oglądanie na żywo (ramki jako `muxpkt`,
stan sygnału i kolejki), nagrania (lista, planowanie, anulowanie, usuwanie, odtwarzanie przez HTSP), miejsce na
dysku, bilety HTTP. Bez obsługi: timeshift (pauza/cofanie na żywo) i reguły nagrań przez HTSP (są w panelu).
Logowanie: w sieciach otwartych niepotrzebne; z innych podaj dowolną nazwę użytkownika i **token dostępu jako
hasło** (skrótów HTSP nie da się sprawdzić względem zapisanych haseł panelu).
* Dopóki tvheadend zajmuje port **9981** (lub **9982**), simply-dvb działa dalej: strumienie są dostępne na porcie panelu,
a port strumieni zostaje przejęty automatycznie (sprawdzane co 15 s), gdy tylko zatrzymasz tvheadend –
bez restartu, a aplikacje w telewizorach zachowują adresy `:9981`.
* Na porcie strumieni dostępne są tylko playlisty, strumienie (TS/HLS), EPG, ikony, publiczne linki
`/watch/…` i metryki – bez panelu i API. Można go wystawić przez router/reverse proxy, a panel zostawić
w LAN (dodatkowo *Dostęp → ACL*). Wszystkie te ścieżki działają też na porcie panelu.
### Przeniesienie listy kanałów z tvheadend
Po skanowaniu `scripts/import-tvheadend.py` kopiuje numery kanałów (opcjonalnie też nazwy, grupy z tagów i stan
włączenia) z tvheadend. Dopasowanie w kilku przebiegach: po usłudze (ONID/TSID/SID albo SID + częstotliwość), po
nazwie, po nazwie bez słów jakości/testu/przedrostków („Zet” = „Radio ZET em.test.”) i po nazwie podobnej; duplikaty
w tvheadend (dwa kanały na jedną usługę) są wypisywane i pomijane. Najpierw pokazuje
plan i bez `--apply` niczego nie zmienia; wymaga tylko Pythona 3 (paczka .deb instaluje go jako
`/usr/share/simply-dvb/import-tvheadend.py`).
```bash
# tvheadend nadal działa (API HTTP, użytkownik z uprawnieniami admina)
scripts/import-tvheadend.py --tvh http://<serwer>:9981 --tvh-user admin --url http://<serwer>:9980 --user admin
# albo z katalogu konfiguracji tvheadend (działa też przy zatrzymanym tvheadend)
sudo scripts/import-tvheadend.py --tvh-config /var/lib/tvheadend --url http://localhost:9980 --user admin \
--names --groups --enabled --apply
```
Opcje: `--names` (tylko nazwy nadane ręcznie w tvheadend; `--names all` kopiuje wszystkie – mogą być nieaktualne,
gdy nadawca zmienił nazwę kanału), `--reset-names` (powrót do bieżących nazw z sygnału), `--groups`, `--enabled`,
`--fuzzy 0.86` (próg podobieństwa, `1` = tylko dokładne nazwy), `--create` (tworzy kanały dla usług, które ich jeszcze nie mają),
`--unmatched keep|after|disable` (co zrobić z kanałami simply-dvb, których tvheadend nie ma; domyślnie numeracja za
importowanymi). Na czas migracji oba mogą działać obok siebie (tvheadend na 9981, panel simply-dvb na własnym porcie);
po zatrzymaniu tvheadend simply-dvb sam przejmie port 9981.
## Punkty dostępu (HTTP)
| Adres | Opis |
|---|---|
| `/playlist.m3u` | Playlista. Parametry: `format=ts\|hls`, `profile=pass\|aac\|h264`, `token=` |
| `/epg.xml` | XMLTV dla włączonych kanałów |
| `/stream/<id>.ts` | Ciągły MPEG-TS kanału (`profile=` opcjonalnie) |
| `/hls/<id>/index.m3u8` | HLS live kanału (`profile=` opcjonalnie) |
| `/watch/<share>` | Publiczna strona z odtwarzaczem (link udostępnienia) |
| `/icons/<id>.png` | Ikona kanału |
| `/recordings/<id>/index.m3u8`, `/recordings/<id>/file` | Nagranie: HLS VOD / plik (obsługa `Range`) |
| `/api/*` | API panelu (JSON, wymaga sesji; zapytania zmieniające stan wymagają nagłówka `X-Requested-With: simply-dvb`) |
| `/metrics` | Metryki Prometheus (dostęp jak do strumieni: sieć lokalna, token, sesja) |
| `/healthz` | Kontrola działania |
Dostęp do strumieni (w tej kolejności): `token=` → `share=` (tylko jeden kanał) → adres klienta w
„sieciach bez tokenu” → sesja panelu → HTTP Basic (hasło = token).
## Odtwarzanie w przeglądarce i profile
Oryginalny strumień (`pass`) jest odtwarzany bez transkodowania zawsze, gdy przeglądarka umie go zdekodować –
hls.js przepakowuje MPEG-TS (H.264, **HEVC**, MPEG audio/MP2, AAC, AC-3) w przeglądarce, serwer nic nie liczy.
| Kodek | Chrome / Edge | Firefox | Safari |
|---|---|---|---|
| H.264, MP2, AAC | tak | tak | tak |
| HEVC (H.265) | tylko z dekodowaniem sprzętowym (Windows/macOS/Android; Linux: VA-API) | Windows/macOS (sprzętowo), Linux 137+ z VA-API | tak |
| AC-3 / E-AC-3 | nie | nie | tak |
Polskie DVB-T2 to HEVC + dźwięk MP2 i E-AC-3: działa w Safari oraz w Chrome/Edge ze sprzętowym dekodowaniem HEVC
(odtwarzacz sam wybiera ścieżkę MP2). W Chrome na Linuksie HEVC wymaga karty z VA-API (Intel/AMD) – sprawdź
`chrome://gpu` („Video Decode: Hardware accelerated”).
Gdy przeglądarka nie obsługuje kodeka, odtwarzacz przełącza się na profil z transkodowaniem – **to wymaga
ffmpeg na serwerze** (`apt install ffmpeg`). Bez ffmpeg odtwarzacz zawsze próbuje oryginału, a gdy się nie uda,
wyjaśnia przyczynę i proponuje *Otwórz w VLC*. Strona Telewizja pokazuje, które kodeki obsługuje bieżąca przeglądarka.
* `pass` – bez zmian,
* `aac` – obraz bez zmian, dźwięk przekodowany do AAC (lekkie),
* `h264` – pełne transkodowanie do H.264 720p (obciąża CPU; argumenty w *Ustawienia → ffmpeg*,
można włączyć VAAPI, np. `-vaapi_device /dev/dri/renderD128 -vf 'format=nv12,hwupload,scale_vaapi=w=-2:h=720' -c:v h264_vaapi`).
Telewizory, VLC i Kodi same dekodują HEVC/E-AC-3, więc playlisty M3U zawsze podają oryginalny strumień.
## Języki
Interfejs, komunikaty serwera i logi są po angielsku; tłumaczenia to pliki JSON w katalogu `langs/`
(format jak w RustProxy). Angielski tekst jest jednocześnie kluczem tłumaczenia.
```json
{
"meta": { "locale": "pl_PL", "name": "Polish", "native_name": "Polski", "direction": "ltr" },
"translations": { "Channels": "Kanały", "Recording scheduled": "Zaplanowano nagranie" },
"patterns": [ { "match": "^Found (\\d+) icons$", "replace": "Znaleziono $1 ikon" } ]
}
```
* `langs/en_US.json` – wymagany (domyślny język i pełny katalog kluczy), `langs/pl_PL.json` – polski,
* nowy język: `node scripts/i18n-missing.js --new de_DE "Deutsch" "German"` tworzy plik ze wszystkimi kluczami;
puste wartości są brane z angielskiego, więc można tłumaczyć stopniowo,
* `node scripts/i18n-missing.js pl_PL` – brakujące wpisy, `node scripts/i18n-missing.js --sources` – teksty panelu bez wpisu w `en_US.json`,
* `patterns` obsługują teksty z wartościami: `$1` – wstawia grupę bez zmian, `$t1` – tłumaczy ją ponownie,
* `build.rs` sprawdza pliki (poprawny JSON, `meta.locale` = nazwa pliku) i wbudowuje je w paczkę JS;
język pojawia się automatycznie w przełączniku w górnym pasku i w *Ustawienia → Wygląd*.
## EPG z eteru i z internetu
* **Z eteru (EIT)** – zbierane podczas oglądania i okresowo z każdego multipleksu (*Ustawienia → EPG*).
* **Z linku XMLTV** – np. `https://epg.ovh/pl.xml` (lub inny dostawca; obsługiwane `.xml` i `.xml.gz`).
Kanały dopasowują się po nazwie; gdy nazwa się różni, wybierz identyfikator w polu *Identyfikator EPG*
kanału (podpowiedzi pochodzą z zaimportowanych źródeł). Dane XMLTV mają pierwszeństwo przed EIT.
## Si2168 – wskazówki
* Firmware: pakiet `firmware-linux-nonfree` (Debian) / `linux-firmware` – pliki `dvb-demod-si2168-*.fw`.
Brak firmware = brak locka; sprawdź `dmesg | grep -i si2168`.
* Test z linii poleceń (bez uruchamiania serwera):
```bash
simply-dvb adapters
simply-dvb tune --freq 538 --system dvbt2
simply-dvb tune --freq 346 --system dvbc --symbol-rate 6900 --modulation qam256
```
* Siła sygnału jest raportowana przez tuner Si2157 w dBm, SNR przez Si2168 w dB.
* DVB-T2 z wieloma PLP: PLP ustawisz przy ręcznym dodawaniu multipleksu.
## Architektura
```
/dev/dvb/adapterN ──► wątek odczytu (frontend+demux+dvr, pełny TS) ──► broadcast
│ │
EIT → kolektor SI → EPG (SQLite) ├─► filtr usługi (PAT/PMT) ─► TS klienta
├─► [ffmpeg] ─► segmenter HLS ─► sesja HLS
└─► segmenter ─► plik nagrania + indeks
```
* `src/dvb` – ioctl Linux DVB, adapter wirtualny, skanowanie,
* `src/ts` – MPEG-TS: pakiety, sekcje PSI/SI z CRC, PAT/PMT/SDT/NIT/EIT/TDT, teksty DVB, PES, generator testowy,
* `src/stream` – filtr usługi i segmenter HLS,
* `src/tuner.rs` – przydział tunerów, współdzielenie, wywłaszczanie, statystyki,
* `src/hls.rs`, `src/pipeline.rs`, `src/recorder.rs`, `src/epg.rs`, `src/scanjob.rs`,
* `src/web` – axum: API, strumienie, panel.
Panel (jak w RustProxy): źródła w `web/css/*.css`, `web/js/*.js` i `langs/*.json` (+ `web/vendor/hls.min.js`) są przy
kompilacji (`build.rs`) łączone w **jeden plik CSS i jeden JS o unikalnych nazwach** (`app.<hash>.css`,
`app.<hash>.js`), wbudowywane w binarkę i serwowane z `Cache-Control: immutable`.
Dane: `<data-dir>/simply-dvb.db` (SQLite), `icons/`, `recordings/`.
## Rozwój
```bash
./dev.sh check # fmt, clippy -D warnings, składnia JS
./dev.sh test # testy jednostkowe + end-to-end (adapter wirtualny: skan, HLS, TS, EPG, ACL, nagrywanie)
./dev.sh run # serwer deweloperski (./data)
./dev.sh docker # obraz Docker
./dev.sh deb-all # .deb dla amd64, arm64 i armhf
./dev.sh dist # check + test + wszystkie .deb + docker
```
Opcje uruchomienia (także jako zmienne środowiskowe): `--data-dir` (`SIMPLY_DVB_DATA_DIR`),
`--dev-root` (`SIMPLY_DVB_DEV_ROOT`), `--virtual-dir` (`SIMPLY_DVB_VIRTUAL_DIR`, katalog z plikami
`<MHz>.ts`), `serve --listen` (`SIMPLY_DVB_LISTEN`, panel, domyślnie 9980), `serve --stream-listen`
(`SIMPLY_DVB_STREAM_LISTEN`, port strumieni, domyślnie 9981, `off` wyłącza). Użytkownicy z linii poleceń:
`simply-dvb user add <login> --role admin|viewer`, `simply-dvb user passwd <login>`.
Tłumaczenia: silnik w `web/js/10-i18n.js`, pakiety w `langs/*.json`. Nowy tekst w interfejsie (po angielsku)
wymaga wpisu w `langs/en_US.json` i tłumaczeń w pozostałych plikach (lub wzorca w `patterns` dla tekstów z wartościami).
Odtwarzacz korzysta z [hls.js](https://github.com/video-dev/hls.js) (Apache-2.0, `web/vendor/`).