# 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, **filtrowanie PID w jądrze** (czytane są tylko PID-y potrzebne klientom oraz tabele EPG/SI – dużo mniej CPU niż cały multipleks; można wyłączyć w Ustawieniach), 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/`, `/xmltv/channels`, `/imagecache/` | | 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/`) – 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, **ruch aplikacji** wg protokołu (MPEG-TS, HLS, HTSP) i z tunerów, klienci/sesje HLS, temperatura, obciążenie; dla tunera: przepływność, siła sygnału (%/dBm), SNR, bloki z błędami, **BER**, **błędy strumienia (CC/TEI)**, etapy synchronizacji (sygnał/nośna/FEC/sync/lock), parametry transmisji, PID-y/wypełnienie i **dane sprzętu** (magistrala, sterownik, produkt, prędkość USB, zakres częstotliwości, możliwości). **Miernik anteny** (*Tunery → Miernik anteny*): duży odczyt siły/SNR na żywo z oceną jakości i opcjonalnym dźwiękiem – do ustawiania anteny z telefonem w ręku. `/metrics` w formacie Prometheus | | Parowanie aplikacji TV | Aplikacja [simply-tv](../simply-tv) na Android TV pokazuje kod QR; po zeskanowaniu otwiera się *Sparuj telewizor* w panelu – po zatwierdzeniu serwer tworzy token dostępu i przekazuje go telewizorowi (`POST /api/pair/start`, `GET /api/pair/poll`, kody wygasają po 10 min) | | Statystyki | Historia oglądania: czas oglądania, najczęściej oglądane kanały, widzowie, urządzenia, protokoły, pora dnia i dni (24 h / 7 / 30 dni / rok) | | Kopia zapasowa | Eksport/import konfiguracji (multipleksy, usługi, kanały, reguły, tokeny, ustawienia) jako JSON; pełna kopia bazy z panelu lub `simply-dvb db backup` | | Interfejs | Angielski (domyślnie) i polski, **dowolna liczba języków** (pliki `langs/.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 **profilu użytkownika** (działają na każdym urządzeniu). **Ulubione kanały** (★, własny filtr i M3U), **przypomnienia o audycjach** (powiadomienie 2 min przed startem), lista zalogowanych urządzeń z wylogowaniem zdalnym, widok na telefon z dolnym paskiem, instalacja jako aplikacja (PWA, HTTPS) | | 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_-1_amd64.deb scripts/build-deb-arm64.sh # Raspberry Pi 3/4/5, 64-bit OS -> dist/simply-dvb_-1_arm64.deb scripts/build-deb-armhf.sh # Raspberry Pi, 32-bit RPi OS -> dist/simply-dvb_-1_armhf.deb scripts/build-deb-all.sh # wszystkie trzy ``` Wszystkie wywołują `scripts/build-deb.sh `. **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://:9980/`, strumienie: `http://: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://:9981/playlist` (format tvheadend) albo `http://:9981/playlist.m3u` (`?format=hls` dla HLS), * EPG: `http://: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 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= tvg-chno=…,Nazwa` | | `/stream/channelid/`, `/stream/channelnumber/`, `/stream/channelname/`, `/stream/channel/` | to samo | ciągły MPEG-TS | | `/playlist/channelid/` | to samo | playlista jednego kanału – np. „Otwórz w VLC” | | `/xmltv`, `/xmltv/channels` | to samo | identyfikatory kanałów = `tvg-id` z playlisty | | `/imagecache/` | to samo | logo kanału | | JSON API `/api/serverinfo`, `/api/channel/grid`, `/api/channeltag/grid`, `/api/epg/events/grid`, `/api/dvr/entry/*`, `/dvrfile/` | 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=`, `?ticket=`, 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://:9981 --tvh-user admin --url http://: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/.ts` | Ciągły MPEG-TS kanału (`profile=` opcjonalnie) | | `/hls//index.m3u8` | HLS live kanału (`profile=` opcjonalnie) | | `/watch/` | Publiczna strona z odtwarzaczem (link udostępnienia) | | `/icons/.png` | Ikona kanału | | `/recordings//index.m3u8`, `/recordings//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. ## Aplikacja TV (simply-tv) Aplikacja na Android TV [simply-tv](../simply-tv) paruje się kodem QR: na telewizorze wpisz adres serwera i wybierz *Paruj kodem QR*, zeskanuj kod telefonem, zaloguj się do panelu i zatwierdź – serwer tworzy token dostępu i przekazuje go telewizorowi (można też wpisać 6-znakowy kod w *Dostęp → Sparuj telewizor*). `/api/status/inputs?channel=` zwraca tuner obsługujący kanał z siłą sygnału, SNR, BER i licznikami błędów. ## Narzędzia wiersza poleceń Uruchamiaj je na serwerze (jako root lub `sudo -u simply-dvb`; pliki tworzone jako root dostają właściciela katalogu danych). Działają bezpośrednio na bazie, także gdy panel jest niedostępny, a działający serwer stosuje zmienione ustawienia w ciągu kilku sekund. ```sh simply-dvb user reset-admin # zapomniane hasło: nowe losowe hasło administratora simply-dvb user passwd [--generate] # zmiana hasła (wylogowuje użytkownika wszędzie) simply-dvb user list | add [--role viewer] [--generate] | role admin|viewer | logout | delete simply-dvb access show # kto ma dostęp do panelu / strumieni bez tokenu simply-dvb access reset-panel # zablokowany przez ograniczenie sieci panelu? dostęp zewsząd simply-dvb access open-add mojdom.ddns.net # strumienie bez tokenu dla sieci/adresu/nazwy DDNS simply-dvb token add tv --allow mojdom.ddns.net --base-url http://192.168.1.10:9981 # wypisuje gotowe adresy simply-dvb token list | enable | disable | delete simply-dvb settings show [klucz] | set | unset simply-dvb channels list [--all] | m3u [--base-url …] [--token …] | enable 1 2 3 | disable 4 simply-dvb db backup [plik] | check | vacuum | restore # restore: najpierw zatrzymaj usługę simply-dvb status # wersja, stan serwera, liczniki, najbliższe nagranie, adaptery simply-dvb doctor # diagnostyka: katalog danych, baza, adaptery/uprawnienia, dysk, ffmpeg simply-dvb adapters | tune --freq 634 # diagnostyka tunera simply-dvb completions bash > /etc/bash_completion.d/simply-dvb # podpowiedzi Tab (bash/zsh/fish) ``` Osobiste ustawienia panelu (język, motyw, kolor, filtry) są zapisywane w profilu użytkownika i działają w każdej przeglądarce i na telefonie. ## 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..css`, `app..js`), wbudowywane w binarkę i serwowane z `Cache-Control: immutable`. Dane: `/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 `.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 --role admin|viewer`, `simply-dvb user passwd `. 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/`).