first commit
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

This commit is contained in:
Mateusz Gruszczyński committed 2026-11-16 16:19:21 +01:00
commit c30064b531
93 files changed
+26367

No files matched your search

+310
View File
@@ -0,0 +1,310 @@
# 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/`).