This is the full developer documentation for Cesbo Astra # Astra > Receive signals from any source and deliver reliable TV to your viewers over cable, satellite, terrestrial, and IP networks ## Is This for You? [Section titled “Is This for You?”](#is-this-for-you) Astra is designed for: * Cable, satellite, and terrestrial TV operators * IPTV and OTT service providers * Content delivery networks (CDNs) * Hotels, hospitals, and others who provide TV services for their own customers ## How Does It Work? [Section titled “How Does It Work?”](#how-does-it-work) Astra runs on Linux servers and gets TV content from various sources, then delivers it to your viewers. ### Receiving content [Section titled “Receiving content”](#receiving-content) Astra supports various types of sources: * Satellite, Cable, and Terrestrial signals using DVB and ISDB-T standards * HLS and HTTP MPEG-TS streams * Multicast streams in IP networks with UDP or RTP * SRT protocol in caller or listener modes * RTSP streams from IP cameras ### Processing content [Section titled “Processing content”](#processing-content) Astra prepares received channels for delivery using MPEG-TS processing features: * MPEG-TS Demultiplexing to extract channels from multi-program streams * Streams filtering and remapping * Descrambling with DVB-CI and Conditional Access Modules * Analyzing streams * Stream redundancy with automatic failover to backup sources when primary feeds fail Astra works on the transport stream level, and delivers content without changing the original video and audio streams. ### Delivering content [Section titled “Delivering content”](#delivering-content) Broadcasting & Streaming content over different networks: * Preparing streams and MPEG-TS multiplexing for cable, terrestrial, and satellite networks * Scrambling using DVB Simulcrypt * HLS and HTTP MPEG-TS streaming with access authentication * Delivery streams over IP networks with UDP Multicast * SRT protocol in listener or caller modes ### Other Features [Section titled “Other Features”](#other-features) * Web-Interface: Control and configure Astra in your browser * Realtime monitoring: Track adapters and streams health * Integration with Zabbix, Grafana, and InfluxDB: Connect with your existing monitoring tools * API: Automate tasks and integrate with other systems * Lua scripts: Customize functionality with scripting # DVB Adapters Overview DVB (Digital Video Broadcasting) is a set of international standards for digital television broadcasting. With Astra you can receive media content from various DVB networks, including satellite, cable, and terrestrial sources. ## DVB Adapter [Section titled “DVB Adapter”](#dvb-adapter) To receive DVB signal on your server, you’ll need additional hardware: DVB Adapter. DVB Adapters are typically PCIe boards, although USB DVB Adapters are also available, but not recommended for production use.  Key components of a DVB adapter: * **Tuner**: also known as a frontend, this component receives the signal, converts analog to digital, and corrects errors * **Demultiplexer**: responsible for processing the received MPEG-TS stream and filtering individual streams * **Common Interface (CI)**: some adapters come with an interface to connect conditional access modules for stream descrambling We recommend DVB adapters by: * [Digital Devices](https://www.digital-devices.eu) * [TBS](https://www.tbsdtv.com) ## Prepare your system [Section titled “Prepare your system”](#prepare-your-system) Before you begin, make sure that the DVB Adapter is connected to your server and that the appropriate Linux driver is installed: * [DigitalDevices Driver Installation](./dd-driver/) * [TBS Driver Installation](./tbs-driver/) ## General options [Section titled “General options”](#general-options) To create new adapter click “New Adapter” in the main menu.  * **Enable**: turn adapter on/off; * **Name**: adapter name; * **ID**: unique adapter identifier. For new adapter you may keep this field blank and Astra generates it; * **Virtual**: virtual adapters is custom interface to receive MPTS streams from different sources like SAT>IP, UDP, CI-Adapters; * **SAT>IP**: use adapter on remote server over SAT>IP protocol (deprecated, use Virtual - SAT>IP instead); * **Adapter**: select system devices; * **Type**: select adapter standard. ## External CI options [Section titled “External CI options”](#external-ci-options) External CI is a DVB-CI adapter like [DigitalDevices Octopus Twin CI](https://www.digital-devices.eu/shop/en/Accessoires/Bridge/266/DD-Octopus-Twin-CI-Double-CI-Slot-with-2-Expansionports-CI4All-Support) or [TBS 6900](https://www.tbsdtv.com/products/tbs6900-dvb-dual-pci-e-card.html) * **CI**: adapter number for DVB-CI device; * **CI Device**: device number on DVB-CI adapter; * **CI Bitrate**: bitrate for TBS DVB-CI adapter in Mbps. Default: 70. ## Advanced options [Section titled “Advanced options”](#advanced-options)  * **Enable monitoring**: enable telemetry sending to Zabbix or InfluxDB; * **Timeout**: check DVR errors in defined interval. Default: 120; * **BISS**: descramble an entire transponder; * **DVB API v3**: use deprecated API to read information from Adapter; * **Budget Mode**: disable hardware PID filtering. In budget mode Astra receives whole transponder from adapter; * **CA Delay**: delay between sending control packets to Conditional Access Module (CAM). ## DVB Type [Section titled “DVB Type”](#dvb-type) Other options depends of the selected adapter type: * [DVB-S/S2](./s/) * [DVB-T/T2](./t/) * [DVB-C](./c/) ## Scan [Section titled “Scan”](#scan) Once your adapter is configured, you can check the signal quality and scan it for available channels. Read more: [Scan DVB Adapter](./scan/) ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) If you have any issues with starting DVB adapter please check our guide: [Troubleshooting](../troubleshooting/dvb/) # DVB Adapter options for DVB-C DVB-C is a standard for digital cable television transmission. ## General options [Section titled “General options”](#general-options)  * **Frequency**: carrier frequency (80-1000 MHz) * **Symbolrate**: symbol rate also known as the baud rate, refers to the number of signal changes per second (1000-10000 Kbaud) ## Advanced options [Section titled “Advanced options”](#advanced-options)  * **Modulation**: method used to convert digital data into an analog signal that can be transmitted over the cable network. In DVB-C, the most commonly used modulation schemes are 64-QAM (Quadrature Amplitude Modulation) * **FEC**: forward error correction is a technique used to reduce errors in the transmission of digital data. In DVB-C, FEC is typically specified using a ratio of the number of redundant bits to the total number of transmitted bits # Driver installation for DigitalDevices DigitalDevices is a hardware manufacturer specialized on DVB devices: tuners, modulators. ## Installation [Section titled “Installation”](#installation) Use the official DigitalDevices script to install the driver. Run the command as `root` or with `sudo`: ```sh curl -sSf http://linuxsupport.digital-devices.eu/dddvb_build.sh | sudo bash -s -- -g ``` The `-g` option tells the script to build the latest driver version from the Git repository. The script installs the required packages, downloads the driver source code, and builds the driver for the current kernel. When the installation is complete, reboot the server. Then [check](#check-driver) that the driver is installed correctly. ## Check Driver [Section titled “Check Driver”](#check-driver) To check if the driver has been installed correctly, list adapters in the dvb directory: ```sh ls /dev/dvb ``` Should be listed all adapters installed in the system. For example: ```plaintext adapter0 adapter1 adapter2 adapter3 ... ``` ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) If you have any issues with your DVB Adapters, please check [Troubleshooting](../../troubleshooting/dvb/) # External DVB-CI > How to use External DVB-CI adapters with Astra for decrypting channels  Many TV providers encrypt their channels using Conditional Access Systems (CAS). DVB-CI (Common Interface) allows you to use a Conditional Access Module (CAM) and smart card to descramble these channels. External DVB-CI adapters provide a flexible way to connect CAMs to Astra. ## Advantages of External DVB-CI [Section titled “Advantages of External DVB-CI”](#advantages-of-external-dvb-ci) * You can group encrypted channels from different sources and decrypt them with a single CI module * Channels can be received on one server and decrypted on another. This is useful if you use SAT>IP receivers. You may have Astra server with CI cards stored in the server room, while SAT>IP receivers are located closer to the roof where satellite dishes are mounted. Read more about [Receiving SAT>IP](../../receiving/dvb/satip-client) with Astra ## Requirements [Section titled “Requirements”](#requirements) * You need an external DVB-CI adapter. Tested models include: * [DigitalDevices Octopus Twin CI](https://www.digital-devices.eu/shop/en/Accessoires/Bridge/266/DD-Octopus-Twin-CI-Double-CI-Slot-with-2-Expansionports-CI4All-Support) * [TBS6900](https://www.tbsdtv.com/products/tbs6900-dvb-dual-pci-e-card.html) * Conditional Access Module (CAM) * SmartCard from broadcaster  ## Create MPTS [Section titled “Create MPTS”](#create-mpts) In Astra settings, create an MPTS stream to collect all channels from different sources. For each input in the MPTS, add the **cas** option to the source address. With this option, Astra passes all necessary data required for channel decryption to the CAM.  ## Create Virtual Adapter [Section titled “Create Virtual Adapter”](#create-virtual-adapter) Caution Virtual Adapter available for versions released after 20 Sep 2022 Create New Adapter in the Astra Web Interface with the `CI` value in the `Virtual` field. Save adapter settings by clicking the Apply button  CI options: * **Name**: adapter name * **ID**: unique identifier. Leave blank to auto-generate * **Virtual**: select **CI** option * **Adapter**: number of the CI adapter in the system * **Stream ID**: ID of the MPTS created earlier * **CI Device**: device number on the CI adapter (default: 0) * **CI Bitrate**: bitrate limit in MBps. Default for TBS: `70`. For DigitalDevices, should be defined in the driver * **CA Delay**: delay (seconds) before sending channel info to the CAM. Default: `20` CI adapter number could be found with command: ```sh find /dev/dvb/ -name ca* ``` For example result will be: ```plaintext /dev/dvb/adapter5/ca0 ``` Where: * `5` - CI adapter number * `0` - device on the CI adapter ## Scan adapter [Section titled “Scan adapter”](#scan-adapter) Click Scan to read channel information from the adapter.  Select the channels you need, turn on the **Set DVB-CI CAM for selected channels** option, and press Apply to add them.  ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) For common CAM-related issues see [CAM Troubleshooting](../../troubleshooting/dvb/cam/). # Internal DVB-CI > How to use Internal DVB-CI adapters with Astra for decrypting channels Some DVB adapters include a built-in Common Interface (CI). These are called **Internal DVB-CI**. An example is the [TBS 6910](https://www.tbsdtv.com/products/tbs6910-dvb-dual-tuner-pcie-card.html), where the DVB tuner is directly connected to the CI slot. ## Astra Configuration [Section titled “Astra Configuration”](#astra-configuration) With Internal CI, no extra configuration is required. You only need to: 1. [Create a DVB adapter](../) in Astra 2. [Scan the adapter](../scan/) and select required channels 3. Enable the option **Set DVB-CI CAM for selected channels** When you enable this option, Astra automatically adds the `cam` parameter to the input address of each selected channel. This tells Astra to use the DVB-CI slot for descrambling. Example of input address with `cam` parameter: ```plaintext dvb://a001#pnr=10&cam ``` ## Log messages [Section titled “Log messages”](#log-messages) When starting the adapter, Astra shows information about the CI slot: ```plaintext 09:00:00[dvb_ca 0:0] CA Slots: 1 09:00:00[dvb_ca 0:0] CA Descramblers: 0 09:00:00[dvb_ca 0:0] Select slot 0 09:00:04[dvb_ca 0:0] CA Slot 0: ready to go 09:00:04[dvb_ca 0:0] CA Slot 0: active ``` After the CAM is detected: ```plaintext 09:00:10: INFO: [dvb_ca 0:0] CA Module Conax CA. 0x01 0x0B00 0x0001 09:00:14: INFO: [dvb_ca 0:0] CA Module CAID:0x0B00 (session 0:3) ``` If debug logging is enabled, you will also see channel selection commands, for example: ```plaintext CA Slot 0.3: first pnr:10 cmd:select ``` This confirms that the channel is sent to the CAM for descrambling. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) For common CAM-related issues see [CAM Troubleshooting](../../troubleshooting/dvb/cam/). # Low-Noise Block for receiving Satellite TV The LNB (Low-Noise Block) is a device used in satellite dishes. It operates in specific frequency bands to receive signals, which it then amplifies and converts to a level optimal for transmission over a coaxial cable.  ## Power supply [Section titled “Power supply”](#power-supply) The power supply for an LNB comes directly from the satellite receiver via the connected coaxial cable. This is usually in the range of 13 to 18 volts, with the voltage level also used to control the polarization of the received signal. * 18 volt is supplied for linear horizontal or circular left polarization, with the switching current typically ranging from 16 to 20 volts * 13 volt is used for linear vertical or circular right polarization, with the switching current generally falling between 11 and 14 volts ## Heterodyne frequency [Section titled “Heterodyne frequency”](#heterodyne-frequency) A commonly used type, the Universal LNB, operates in the Ku-band, with frequencies ranging from 10700 to 12750 MHz. This LNB utilizes two Local Oscillators (LOs): one set at 9750 MHz for the low-band (10700 - 11700 MHz) and another set at 10600 MHz for the high-band (11700 - 12750 MHz). When a signal is received, it is mixed with the appropriate LO frequency. This results in an Intermediate Frequency (IF) signal ranging from 950 to 2150 MHz, which can be effectively transmitted over the coaxial cable. The selection between the two Local Oscillators in a Universal LNB is controlled by a 22 kHz tone signal sent by the satellite receiver over the coaxial cable. ## Quattro LNB [Section titled “Quattro LNB”](#quattro-lnb) A Quattro LNB has four outputs, each dedicated to a specific band and polarization. This type of LNB designed for: * Fiber transmitters * Multiswitch systems with up to 32 independent outputs * Multiswitch with Unicable protocol  ## Quad LNB [Section titled “Quad LNB”](#quad-lnb) A Quad LNB has for independent outputs, each capable of accessing all frequencies in the Ku-band. Note It’s important to note that a Quad LNB is designed for consumer use. Quattro LNB is not intended for direct connection to a receiver. The two types of LNBs are distinctly different and cannot replace each other in their respective applications. Be careful not to confuse them. # DVB Adapter options for DVB-S/S2 DVB-S/S2 is a standard for Satellite Television ## General options [Section titled “General options”](#general-options)  * **Frequency**: carrier frequency (950-13250 MHz) * **Polarization**: signal polarization. For linear polarization: Vertical, Horizontal. For circular polarization: Right, Left * **Symbolrate**: symbol rate also known as the baud rate, refers to the number of signal changes per second (1000-50000 Kbaud) ## LNB (Low-Noise Block) options [Section titled “LNB (Low-Noise Block) options”](#lnb-low-noise-block-options)  * **LOF1**: Low sub-band, MHz * **LOF2**: High sub-band, MHz * **SLOF**: Sub-band range. If adapter frequency more than SLOF, than will be used LOF2 value and sends tone (22 kHz) signal to LNB to switch * **Force Tone**: option to send 22 KHz tone signal * **LNB Mode**: select additional LNB modes Default options depends on the adapter frequency: | Frequency range | LOF1 | LOF2 | SLOF | | --------------- | ---- | ----- | ----- | | 10700 .. 13250 | 9750 | 10600 | 11700 | | 4500 .. 4800 | 5950 | 0 | 0 | | 3400 .. 4200 | 5150 | 0 | 0 | | 2500 .. 2700 | 3650 | 0 | 0 | | 950 .. 2150 | 0 | 0 | 0 | Tip For circular polarized converters (e.g. 36°E, 56°E), set 10750 in LOF1 ## LNB Polarization [Section titled “LNB Polarization”](#lnb-polarization) The LNB polarization option controls the signal received by the satellite dish. The voltage level for LNB power supply is defined by the polarization: * 13V is for Vertical/Right polarization. Switching signal in the range of 11-14 Volts * 18V is for Horizontal/Left polarization. Switching signal in the range of 16-20 Volts ## LNB Modes [Section titled “LNB Modes”](#lnb-modes) * **LNB Sharing**: in this mode, the LNB voltage supply and tone signal are disabled. This allows you to connect several DVB-adapters to a single converter through a passive splitter. On the splitter, only one adapter must be active; the any other adapters should be passive. All adapters on the same splitter should use the same polarization and the same sub-band (frequency greater or less than the value of slof) * **DiSEqC 1.0**: digital Satellite Equipment Control is a communication protocol for use between a satellite receiver and a device such as a multi-dish switch or a small dish antenna rotor. Version 1.0 allows switching between up to 4 satellite sources * **DiSEqC 1.1**: allows switching between up to 16 satellite sources * **DiSEqC Command**: sends a raw command to DiSEqC * **Tone Burst**: also known as mini DiSEqC. Allows switching between 2 satellite sources * **Unicable I (EN50494)**: provides simultaneous access to multiple LNBs over a single coaxial cable for several receivers. Version I provides access up to 8 satellite sources * **Unicable II (EN50607)**: provides access to up to 32 satellite sources ## Advanced options [Section titled “Advanced options”](#advanced-options)  * **Modulation**: method used to convert digital data into an analog signal. Default: QPSK for DVB-S, PSK8 for DVB-S2 * **FEC**: forward error correction. Default: Auto * **Roll-Off**: spectrum efficiency. Only for DVB-S2. Default: 35 * **Stream ID**: PLP stream ID for multistream transponders. Only for DVB-S2  # Scan DVB Adapter Open any adapter options and press the Scan button to get available information from adapter:   You can append channels to Astra by selecting all the channels you want to add and then pressing the “Apply” button. # DVB Adapter options for DVB-T/T2 and ISDB-T DVB-T/T2 is a standard for the broadcast transmission of digital terrestrial television. ## General options [Section titled “General options”](#general-options)  * **Frequency**: carrier frequency (0-1000 MHz) ## Advanced Options [Section titled “Advanced Options”](#advanced-options)  * **Bandwidth**: signal bandwidth in kHz determines the amount of data that can be transmitted. Default: 8000 * **Guard**: guard interval used to prevent intersymbol interference (ISI) caused by multi-path propagation of the transmitted signal. The larger the guard interval, the more robust the signal against ISI, but at the cost of lower data rates * **Transmit**: COFDM (Coded Orthogonal Frequency Division Multiplexing) transmission modes to adapt to different channel conditions and maximize the robustness of the transmitted signal. For example: 2K mode uses 2048 sub-carriers to transmit the digital signal, and is suitable for transmitting the signal over short distances with low to moderate signal interference. 8K mode is suitable for transmitting the signal over very long distances or in areas with very high levels of signal interference * **Hierarchy**: hierarchical modulation schemes, which allow for the transmission of two different bitstreams with different levels of robustness # Driver installation for TBS TBS is a hardware manufacturer specialized on DVB devices: tuners, modulators. ## Installation [Section titled “Installation”](#installation) ### Prepare System [Section titled “Prepare System”](#prepare-system) Install `bzip2` - it is required by the driver installer but is not included by default on Ubuntu: ```sh apt install bzip2 ``` Create firmware directory for DVB adapters: ```sh mkdir -p /lib/firmware ``` To allow automatic confirmation of additional packages during installation, configure apt before running the script: ```sh echo 'APT::Get::Assume-Yes "true";' >/tmp/apt.conf export DEBIAN_FRONTEND=noninteractive export APT_CONFIG=/tmp/apt.conf ``` ### Install Driver [Section titled “Install Driver”](#install-driver) Use the official TBS script to install the driver. Run the command as `root` or with `sudo`: ```sh curl -sSf https://www.tbsdtv.com/download/document/linux/drv-tbs.sh | sudo bash -s ``` The script installs the required packages, downloads the driver source code, and builds the driver for the current kernel. Note If you have any issues with driver installation, contact TBS support: When the installation is complete, reboot the server. Then [check](#check-driver) that the driver is installed correctly. ## Check Driver [Section titled “Check Driver”](#check-driver) To check if the driver has been installed correctly, list adapters in the dvb directory: ```sh ls /dev/dvb ``` Should be listed all adapters installed in the system. For example: ```plaintext adapter0 adapter1 adapter2 adapter3 ... ``` ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) You can contact TBS representatives for help installing drivers at this link: - select “Software installation and debugging” If you have any issues with your DVB Adapters, please check [Troubleshooting](../../troubleshooting/dvb/) # How to call API methods in Astra? API (Application Programming Interface) is a methods to access data and interact with software components. ## Call GET methods with curl [Section titled “Call GET methods with curl”](#call-get-methods-with-curl) You may use `curl` in the console to call an API method. For example, you can obtain a summary status of the process and system: ```sh curl \ --user login:password \ http://server:8000/api/system-status ``` * `login:password` - is an admin login and password * `server:8000` - server address and primary port * `/api/system-status` - path to API method ## Call POST method with curl [Section titled “Call POST method with curl”](#call-post-method-with-curl) POST methods used to modify Astra configuration. For example you may toggle user from the console: ```sh curl \ -X POST \ --user login:password \ -d '{"cmd":"toggle-user","id":"login"}' \ http://server:8000/control/ ``` * `login:password` - is an admin login and password * `-d '{...}'` - request content in JSON format * `server:8000` - server address and primary port Another method to execute `curl` where configuration file passed to the standard input: ```sh curl -X POST --user login -d @- http://server:8000/control/ < 'toggle-user', 'id' => 'login', )); $ch = curl_init("http://server:8000/control/"); curl_setopt($ch, CURLOPT_HEADER, 1); curl_setopt($ch, CURLOPT_POST, 1); curl_setopt($ch, CURLOPT_USERPWD, "login:password"); curl_setopt($ch, CURLOPT_POSTFIELDS, $req); curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json')); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); $res = curl_exec($ch); curl_close($ch); ``` # DVB Adapters API In the Astra interface, you can manage DVB Adapter configurations and control their status using HTTP API methods. ## Adapter configuration [Section titled “Adapter configuration”](#adapter-configuration) ```json { "id": "...", "name": "...", "type": "...", "enable": true, "adapter": 0, "device": 0 } ``` * `name` - adapter name; * `type` - adapter type: `S`, `S2`, `T`, `T2`, `ATSC`, `ISDB-T`, `C`, `C/A`, `C/B`, `C/C`; * `enable` - `true` if adapter is enabled; * `adapter` - number of adapter in the system: `/dev/dvb/adapter0` * `device` - number of the device in the adapter: `/dev/dvb/adapter0/frontend0` * other options depends of the adapter configuration ## Obtain Adapter configuration [Section titled “Obtain Adapter configuration”](#obtain-adapter-configuration) Request: `GET /api/adapter-info/{id}` * `id` - unique adapter identifier In response will be JSON with adapter configuration ## Modify Adapter configuration [Section titled “Modify Adapter configuration”](#modify-adapter-configuration) Request: `POST /control/` ```json { "cmd": "set-adapter", "id": "...", "adapter": {...} } ``` * `id` - unique adapter identifier * `adapter` - adapter configuration ## Restart Adapter [Section titled “Restart Adapter”](#restart-adapter) Request: `POST /control/` ```json { "cmd": "restart-adapter", "id": "..." } ``` * `id` - unique adapter identifier ## Remove Adapter [Section titled “Remove Adapter”](#remove-adapter) Danger This method removes adapter and all related streams Request: `POST /control/` ```json { "cmd": "set-adapter", "id": "...", "adapter": { "remove": true } } ``` * `id` - unique adapter identifier ## Obtain Adapter Status [Section titled “Obtain Adapter Status”](#obtain-adapter-status) Request: `GET /api/adapter-status/{id}` * `id` - unique adapter identifier Optional query parameters: `GET /api/adapter-status/{id}?t={time}` * `time` - default is `1` - statistics for last minute, `0` - statistics for last second (current adapter status) Response: ```json { "timestamp": 0, "instance": "...", "name": "...", "lock": true, "signal": 0, "signal_db": 0, "snr": 0, "snr_db": 0, "ber": 0, "unc": 0, "bitrate": 0 } ``` * `timestamp` - report time, for `t=0` is a current time; * `instance` - instance name if defined in the Settings → General → Instance Name; * `name` - stream name; * `lock` - `true` if tuner has lock and able to receive data; * `signal` - approximate signal level in percent; * `signal_db` - signal level in dBm multiplied by 100; * `snr` - approximate signal to noise ratio in percent; * `snr_db` - signal to noise ratio in dB multiplied by 100; * `ber` - bit errors counter; * `unc` - block errors counter; * `bitrate` - total bitrate in Kbit/s. # Other API Methods ## Astra Version [Section titled “Astra Version”](#astra-version) Request: `POST /control/` ```json { "cmd": "version" } ``` ## Astra Restart [Section titled “Astra Restart”](#astra-restart) Request: `POST /control/` ```json { "cmd": "restart" } ``` ## Download configuration [Section titled “Download configuration”](#download-configuration) Request: `POST /control/` ```json { "cmd": "load" } ``` In the response will be whole configuration file. ## Upload configuration [Section titled “Upload configuration”](#upload-configuration) Request: `POST /control/` ```json { "cmd": "upload" "config": {} } ``` * `config` - whole configuration file ## Set serial number [Section titled “Set serial number”](#set-serial-number) Request: `POST /control/` ```json { "cmd": "set-license", "license": "xxx" } ``` * `license` - license serial number ## Set image to the stream tile [Section titled “Set image to the stream tile”](#set-image-to-the-stream-tile) Request: `POST /control/` ```json { "cmd": "set-stream-image", "id": "a001", "url": "http://..." } ``` * `id` - stream identifier * `url` - image address, as well could be used data-format, for example: `data:image/png;base64,...` This method used in the script to set screenshots for stream tiles. Read more in [Channel Screenshots on Dashboard](../../tools/mosaic/) # Process Status API In Astra, you can manage process and control it status using HTTP API methods. ## System status [Section titled “System status”](#system-status) Request: `GET /api/system-status` Optional query parameters: `GET /api/system-status?t={time}` * `time` - default is `1` - statistics for last minute. `0` - statistics for last second (current system status). Response: ```json { "timestamp": 0, "instance": "...", "la1": 0, "la5": 0, "la15": 0, "app_threads": 1, "sys_cpu_usage": 0, "app_cpu_usage": 0, "sys_mem_usage": 0, "app_mem_usage": 0, "app_mem_kb": 0, "sys_uptime": 0, "app_uptime": 0 } ``` * `timestamp` - report time, for `t=0` is a current time * `instance` - instance name if defined in the Settings → General → Instance Name * `la1` - load average for 1 minute multiplied by 100 * `la5` - load average for 5 minutes multiplied by 100 * `la15` - load average for 15 minutes multiplied by 100 * `app_threads` - number of the threads * `sys_cpu_usage` - total CPU usage. Could be up to: 100 multiplied with the core numbers on all CPUs * `app_cpu_usage` - CPU usage by the process and all threads * `sys_mem_usage` - total RAM usage * `app_mem_usage` - RAM usage by the process and all threads * `app_mem_kb` - RAM usage by the process and all threads in kilobytes * `sys_uptime` - total system uptime in seconds * `app_uptime` - process uptime in seconds ## Restart Astra [Section titled “Restart Astra”](#restart-astra) Request: `POST /control/` ```json { "cmd": "restart" } ``` # Scan API ## Start Analyzer [Section titled “Start Analyzer”](#start-analyzer) Request: `POST /control/` ```json { "cmd": "scan-init", "scan": "..." } ``` * `scan` - stream address. Read more about [Media Address Format](../../quick-start/address-format/) Response: ```json { "scan-init": "ok", "id": "..." } ``` * `id` - identifier of the created analyzer instance Analyzer will be stopped automatically in 10 seconds. To keep analyzer active for longer, use `scan-check` API method. ## Stop Analyzer [Section titled “Stop Analyzer”](#stop-analyzer) Request: `POST /control/` ```json { "cmd": "scan-kill", "id": "..." } ``` * `id` - identifier of the analyzer instance This method stops analyzer immediately. ## Get Information [Section titled “Get Information”](#get-information) Request: `POST /control/` ```json { "cmd": "scan-check", "id": "..." } ``` * `id` - identifier of the analyzer instance Response: ```json { "scan-check": "ok", "scan": [ { "psi": "...", "table_id": N, "pid": N, "version": N, "crc32": N, ... } ] } ``` * `scan` - array with stream information, if no any new information this field will be omitted Stream information: * `psi` - Program Stream Information (PSI) packet name. Could be: `pat`, `pmt`, `cat`, `nit`, `sdt` * `table_id` - PSI identifier * `pid` - MPEG-TS packet identifier * `version` - PSI packet version * `crc32` - PSI packet checksum Additional fields depen of the PSI type. ### PAT [Section titled “PAT”](#pat) Program Association Table (PAT) is a list of programs. Contains Program Number (PNR) and Packet Identifier (PID) of the associated PMT. Additional fields: ```json { "psi": "pat", "table_id": 0, "pid": 0, "tsid": N, "programs": [ { "pnr": N, "pid": N } ] } ``` * `table_id` - always `0` * `pid` - always `0` * `tsid` - Transport Stream identifier * `programs` - list of programs Program information: * `pnr` - program number * `pid` - MPEG-TS packet identifier for PMT ### PMT [Section titled “PMT”](#pmt) Program Mapping Table (PMT) is a list of program elementary streams: Video, Audio, and other data. Additional fields: ```json { "psi": "pmt", "table_id": 2, "pnr": N, "pid": N, "pcr": N, "streams": [ { "pid": N, "type_name": "...", "type_id": N, "descriptors": [ { "type_id": N, "type_name": "...", ... } ] } ] } ``` * `table_id` - always `2` * `pid` - MPEG-TS packet identifier * `pnr` - Program Number * `pcr` - MPEG-TS packet identifier for packets with the Program Clock Reference (PCR) timestamps * `streams` - list of program elementary streams Elementary Stream information: * `pid` - MPEG-TS packet identifier for elementary stream * `type_name` - elementary stream type: `VIDEO`, `AUDIO`, `SUB`, `TTX`, `AIT`, `DATA` * `type_id` - elementary stream identifier * `descriptors` - elementary stream descriptors contains additional information # Sessions API Sessions is a list of active connections to HTTP MPEG-TS or HLS outputs. ## Get session list [Section titled “Get session list”](#get-session-list) ```plaintext { "cmd": "sessions" } ``` In response will be array of active sessions: ```plaintext { "sessions": [ { "client_id": "...", "channel_id": "...", "channel_name": "...", "addr": "...", "uptime": N } ] } ``` * `client_id` — unique session identifier * `channel_id` — unique channel identifier * `channel_name` — channel name * `addr` — client IP address * `uptime` — the time in seconds, for which the session has been running ## Close session [Section titled “Close session”](#close-session) ```plaintext { "cmd": "close-session", "id": "..." } ``` * `id` — session identifier # Streams API In the Astra interface, you can manage Stream configurations and control their status using HTTP API methods. Note Configurable parameters are similar to those used in the Astra interface configuration, you can read more on the relevant articles about configuring these parameters. Read more ## Stream configuration [Section titled “Stream configuration”](#stream-configuration) ```json { "id": "...", "name": "...", "type": "...", "enable": true, "input": [ "" ] } ``` * `name` - stream name * `type` - stream type `spts` or `mpts` * `enable` - `true` if stream is enabled * `input` - list of the stream inputs * other options depends of the stream configuration. ## Get Stream configuration [Section titled “Get Stream configuration”](#get-stream-configuration) Request: `GET /api/stream-info/{id}` * `id` - unique stream identifier In response will be JSON with stream configuration ## Modify Stream configuration [Section titled “Modify Stream configuration”](#modify-stream-configuration) Request: `POST /control/` ```json { "id": "...", "cmd": "set-stream", "stream": { ... } } ``` * `id` - unique stream identifier * `stream` - stream configuration ## Toggle Stream [Section titled “Toggle Stream”](#toggle-stream) Turn stream on/off. Request: `POST /control/` ```json { "cmd": "toggle-stream", "id": "..." } ``` * `id` - unique stream identifier Tip You may enable or disable stream by launching next command: ```sh curl \ -X POST \ --user login \ -d '{"cmd":"toggle-stream", "id":"a001"}' \ http://server:8000/control/ ``` on successful Astra returns: ```json { "toggle-stream": "ok" } ``` ## Restart Stream [Section titled “Restart Stream”](#restart-stream) Request: `POST /control/` ```json { "cmd": "restart-stream", "id": "..." } ``` * `id` - unique stream identifier ## Switch active input [Section titled “Switch active input”](#switch-active-input) Choose active input. Works only for streams with next backup types: `passive` or `disable`. Request: `POST /control/` ```json { "cmd": "set-stream-input", "id": "...", "input": "..." } ``` * `id` - unique stream identifier * `input` – input number. Numbering starts from 1. If option not defined will be started next input after the active input Tip You may switch stream input by launching next command: ```sh curl \ -X POST \ --user login \ -d '{"cmd":"set-stream-input", "id":"a001", "input": 2}' \ http://server:8000/control/ ``` on successful Astra returns: ```json { "set-stream-input": "ok" } ``` ## Delete Stream [Section titled “Delete Stream”](#delete-stream) Request: `POST /control/` ```json { "cmd": "set-stream", "id": "...", "stream": { "remove": true } } ``` * `id` - unique stream identifier ## Get Stream Status [Section titled “Get Stream Status”](#get-stream-status) Request: `GET /api/stream-status/{id}` * `id` - unique stream identifier Optional query parameters: `GET /api/stream-status/{id}?t={time}` * `time` - default is `1` - statistics for last minute. `0` - statistics for last second (current stream status). Response: ```json { "timestamp": 0, "instance": "...", "name": "...", "input_id": 1, "active": true, "onair": true, "sessions": 0, "bitrate": 0, "packets": 0, "pes_error": 0, "sc_error": 0, "cc_error": 0, "video_count": 1, "audio_count": 1 } ``` * `timestamp` - report time, for `t=0` is a current time * `instance` - instance name if defined in the Settings → General → Instance Name * `name` - stream name * `input_id` - active input identifier. for example if primary works fine will be 1. if stream switched to the backup input will be number of this input * `active` - `true` if stream is active, or `false` if stream work on demand and inactive * `onair` - `true` if active input works without errors * `sessions` - number of active sessions on the stream * `bitrate` - stream bitrate in Kbit/s * `pes_error` - number of invalid PES-packets packets * `sc_error` - number of scrambled TS-packets. If stream is protected with Conditional Access System (CAS) then `sc_error` and `pes_error` will be greater than 0. If stream descrambled with invalid key then `sc_error` will be equal to 0 and `pes_error` will be greater than 0 * `cc_error` - CC errors counter. CC error can be caused by packets loss or excess * `video_count` - number of video streams * `audio_count` - number of audio streams # Users API Users used to control access to the Astra Web Interface as well as access to the HTTP MPEG-TS and HLS outputs ## User configuration [Section titled “User configuration”](#user-configuration) ```json { "enable": true, "type": 0, "comment": "...", "token": "...", "ip": "...", "expire": 0, "conlimit": 0 } ``` * `enable` – enabled account or not * `type` – user type * `1` - admin. full access to the Astra Web Interface * `2` - observer. read only access to the Astra Web Interface * `3` - regular user. without access to the Astra Web Interface * `comment` - optional field, for user description Optional fields for buil-in authorization to access HLS or HTTP MPEG-TS channels: * `token` - token used in HTTP requests. For example: `http://server:8000/play/a001/index.m3u8?token=secret` * `ip` - allow access to the channels by the client IP address * `expire` - date in unix timestamp format, when access to channels will be restricted * `connlimit` - limit connections to channels ## Get user [Section titled “Get user”](#get-user) Request: `POST /control/` ```json { "cmd": "get-user", "id": "..." } ``` * `id` - user login In response will be JSON with user configuration ## Create or update user [Section titled “Create or update user”](#create-or-update-user) Request: `POST /control/` ```json { "cmd": "set-user", "id": "...", "user": { "enable": true, "type": 0, "password": "..." } } ``` * `id` – user login * `user` - user configuration * `password` - plain password, in the config will be saved the password hash Example You may create new user by launching next command: ```sh curl -X POST --user login -d @- http://server:8000/control/ < Release notes and feature updates for recent Astra versions ## 250612 [Section titled “250612”](#250612) [Download Astra-250612](https://cdn.cesbo.com/astra/builds/astra-250612) ### HTTP Input [Section titled “HTTP Input”](#http-input) * option referrer for HTTP input to set Referer header: `&referrer=http://example.com` ### HLS/HTTP Output [Section titled “HLS/HTTP Output”](#hlshttp-output) * fix application crash on using HTTP MPEG-TS session with HLS output * hide log messages `sending content to ... failed` ### Web Interface [Section titled “Web Interface”](#web-interface) * fix dark colors for minimized cards on dashboard * fix `/api/adapter-status` for Adapter with disabled monitoring * fix sessions list * check cpu frequency on start and show warning if cpu frequency scaling is enabled ### SRT Output [Section titled “SRT Output”](#srt-output) * option `streamid` for caller mode * option `statsout` for listener mode to write receiving stats to CSV file ### UDP Output [Section titled “UDP Output”](#udp-output) * option `reload=HHMM` to restart UDP output at specified time (24h format). Example: `&reload=0300` to restart output at 3:00 AM daily * source-filter attribute for SAP if local address defined in UDP output ### DVB Input [Section titled “DVB Input”](#dvb-input) * option `bbframe` for DigitalDevices adapters to receive BBFRAME from DVB instead of TS packets. Used as a workaround for DVB-S2 Multistream on Eutelsat 5W * fix application crash on “ci-device not found” * support for TBS6522H ## 250221 [Section titled “250221”](#250221) [Download Astra-250221](https://cdn.cesbo.com/astra/builds/astra-250221) ### SRT [Section titled “SRT”](#srt) * SRT library downgraded to v1.4.3 due to packet loss and CC errors * SRT input automatically restarts connections when the bitrate dropped to zero ### DVB [Section titled “DVB”](#dvb) * Option `restart_adapter` to restart DVB adapter with channel analyzer. When channel receives stream with errors it send command to restart adapter. * Fixed crash on starting DVB from Lua scripts * SAT>IP sends options to the SAT>IP server for Multistream/PLS ### UDP [Section titled “UDP”](#udp) * Fixed logs storm with message “UDP recv buffer overflow” * Added option `join` for UDP output to send Multicast Join request (required by some network switches) * Added option `ts_size=204` for MPEG-TS with 204 byte packets (ISDB-T streams in Brazil and Japan) ### MPEG-TS [Section titled “MPEG-TS”](#mpeg-ts) * Fixed remap for AIT packets ### Web Interface [Section titled “Web Interface”](#web-interface-1) * Links to m3u-playlists with different sources (HLS, HTTP MPEG-TS, UDP): Settings → HTTP Play ## Archive Versions [Section titled “Archive Versions”](#archive-versions) All versions with release dates and download links: [Versions](../quick-start/versions/) # CAS and Simulcrypt Conditional Access System (CAS) is a complex solution to protect media content from unauthorized access. Astra can communicates with Conditional Access Systems such as Conax via the Simulcrypt protocol and encrypt media content using the Common Scrambling Algorithm (CSA).  Note Content encryption is effective for protecting broadcast delivery methods such as satellite, cable, and terrestrial. However, for OTT delivery, more suitable methods and combination of content protection techniques are recommended for comprehensive protection against piracy. ## CAS Configuration [Section titled “CAS Configuration”](#cas-configuration) Choose in main menu Settings and click on CAS.  Select a CAS profile, or create a new one by selecting the New CAS item.  * **Name**: arbitrary name-used for easy identification; * **Super CAS ID**: CAS Identifier is an 8 hexadecimal symbols; * **Start Stream ID with 1**: by default, stream numbering starts at 0. For some CAS (example: CTI), the numbering should be starts at 1; * **ECMG Channel ID**: channel number when connecting to CAS; * **ECMG Address**: IP address of the ECMG server; * **ECMG Port**: server ECMG port; * **Crypto period**: Key change interval, usually 10 seconds; * **EMMG Protocol**: The current implementation uses TCP; * **EMMG Port**: The port where the Astra will wait for a connection from the EMG server; * **EMM PID**: PID for EMM packages in the system (user Defined); * **EMM Private Data**: data to add to the CAT table. This data issued in the CAS software. If you do not have data, then this parameter is not filled; * **EMM Clone**: this checkbox activates the function of adding EMM to each encrypted CAS channel. EMM package will be available on any channel at the end user. ## Channel Configuration [Section titled “Channel Configuration”](#channel-configuration) The next step is to configure the channels and append one or more Conditional Access Systems (CAS) to each channel. To do this, open the Dashboard and select the channel that you want to protect. Then, go to the Service tab in the channel settings and click “New CAS” to attach the CAS:  * **ECM PID**: PID for ECM packages (User defined); * **ECM Private Data**: the data of the conditional access system is added to the description of the ECM stream in the PMT table. If these parameters do not exist, you do not need to add thems; * **Access Criteria**: this data will be provided by the CAS provider or defined on the CAS server. ## Conditional Access System [Section titled “Conditional Access System”](#conditional-access-system) TVCAS4 is a Conditional Access System (CAS) that provides a secure and reliable solution for protecting media content. TVCAS4 is a software-based solution that can be installed on a server and integrated with Astra via the Simulcrypt protocol. On the client side you may use a CAM module or a set-top box with a built-in Virtual CAS. Check the [tvcas.com](https://tvcas.com/en/) for more information. # BISS BISS is a basic conditional access system with a static key to protect content from unauthorized access. Caution BISS has weak protection and can be broken with brute force attacks. Use it only when stronger encryption isn’t available. ## BISS Key Format [Section titled “BISS Key Format”](#biss-key-format) BISS keys are 16 hexadecimal characters long. You can use either format: * Full key with checksums: `1234569C789ABCCE` (16 characters) * Simplified key: `12345600789ABC00` (Astra calculates checksums automatically) We recommend using the simplified format to avoid checksum calculation errors. ## Encrypting a Stream [Section titled “Encrypting a Stream”](#encrypting-a-stream) Add the `biss` option with your key to the output address: ```plaintext udp://239.255.1.1:1234#biss=12345600789ABC00 ``` ### Key without Checksums [Section titled “Key without Checksums”](#key-without-checksums) In version 250502 and later, you can use a BISS key as is, without checksum calculation. Append option `no_checksum` to the address: ```plaintext udp://239.255.1.1:1234#biss=12345600789ABC00&no_checksum ``` As a result, the key will be used as is, without calculating checksums. ## Checking if Encryption Works [Section titled “Checking if Encryption Works”](#checking-if-encryption-works) Use the Astra analyzer to verify the stream is scrambled: ```sh astra --analyze udp://239.255.1.1:1234 ``` The analyzer will show messages confirming the stream is scrambled. ## Playing Encrypted Streams [Section titled “Playing Encrypted Streams”](#playing-encrypted-streams) **With VLC Player:** ```sh vlc --ts-csa-ck 1234569C789ABCCE udp://@239.255.1.1:1234 ``` Note: VLC requires the full key with checksums. **With Astra:** See [How to decrypt BISS CAS](../../../streams/processing/decrypt-biss/) for receiving encrypted streams. # HiDes DVB-T Modulator PT100 is a DVB-T modulator for 4 frequencies by HiDes  Features: * 4 modulators on the board * Frequency range 50\~950MHz step size 1KHz * Modulation - 64QAM/16QAM/QPSK * Signal/Noise: 45dB * RF Output Level -8 dBm (100 dBuV) [Read more](http://hides.com.tw/product_pt100_eng.html) ## Setup [Section titled “Setup”](#setup) Driver could be downloaded from [official site](http://hides.com.tw/downloads_eng.html) After installation find the modulators number using the command: ```sh find "/dev" -name "it950x*" ``` In the output of the command, we will get the numbers of the modulators: ```plaintext /dev/usb-it950x1 /dev/usb-it950x0 ``` * `it950x1`: where 1 is the modulator number ## Astra settings [Section titled “Astra settings”](#astra-settings) Prepare [MPTS](../../../streams/mpts/) for modulator. In the MPTS NIT settings, configure transponder options:  In the output setting, specify the type it950x and adapter number: `it950x://#adapter=0` (0 - modulator number) ### Additional output options [Section titled “Additional output options”](#additional-output-options) Additional options could be added to the output address: * `gain=N`: signal level in range from 0 to 100 * `fec=1/2`: FEC coding ratio. Values: `1/2`, `2/3`, `3/4`, `5/6`, `7/8`, `none` # HLS for Broadcasting When you send HLS streams to broadcasting networks like satellite, cable, or terrestrial TV, you might see problems like pixelated video, audio drift, or clicking sounds. The same streams work fine on computers. This happens because HLS and broadcasting networks handle video data differently. ## Video Encoding [Section titled “Video Encoding”](#video-encoding) Video encoding compresses video data to make files smaller. ### Frames [Section titled “Frames”](#frames) Video streams use different types of frames: * **Keyframe (I-frame)** - contains a complete picture * **Subsequent frames (P-frames and B-frames)** - only store changes from the previous frame ### GOP (Group of Pictures) [Section titled “GOP (Group of Pictures)”](#gop-group-of-pictures) GOP is a sequence that starts with a keyframe followed by several subsequent frames. For example, a GOP of 30 means one keyframe followed by 29 other frames. Larger GOP sizes mean fewer keyframes, which reduces file size but creates bigger bitrate spikes when keyframes appear. ## Stream Bitrate [Section titled “Stream Bitrate”](#stream-bitrate) Broadcasting networks need video frames delivered at exact times to keep audio and video in sync. This requires a steady, predictable bitrate. You need to balance GOP size and video quality to maintain consistent bitrate for smooth broadcasting.  HLS works differently. It sends video in chunks of several seconds (usually 3+ seconds), so it can handle bitrate changes better. This allows HLS to use larger GOP sizes and get better video quality with lower average bitrate.  The chart shows that HLS streams average 2 Mbps but can spike to 6 Mbps. This flexibility causes problems for broadcasting networks, which need consistent bandwidth. When you use HLS streams with broadcasting systems, you must adjust the encoding to match broadcasting requirements. ## Bitrate Peaks and UDP Broadcasting [Section titled “Bitrate Peaks and UDP Broadcasting”](#bitrate-peaks-and-udp-broadcasting) Bitrate spikes also cause problems with UDP broadcasting. Set-top boxes and TVs have small network buffers. When too many packets arrive at once during bitrate spikes, the buffer overflows and packets get lost. ## Solution [Section titled “Solution”](#solution) Astra has no built-in transcoding capabilities. You need to transcode the stream using external tools like FFmpeg. Try these settings: * **Reduce GOP size**: Use around 30 frames for better motion quality and smaller bitrate spikes * **Enable interlacing**: Provides smoother motion, especially for broadcasting * **Use CBR (Constant Bitrate)**: This fills bitrate gaps with null packets to achieve a constant rate # DigitalDevices RESI DVB-C Modulator The RESI, a DVB-C modulator by Digital Devices, outputs a DVB-C compatible data stream into an existing 75-ohm coaxial cabling.  Technical specifications: * 4 - 24 Transponder according to DVB-C specification * Frequency range: 114 – 858 MHz * Symbol rates: 1,0 – 7,1 MSym/s * QAM: 16, 32, 64, 128, 256 * Signal / Noise ratio: 42dB * Output with 8 channels (per channel): 101 dBµV ## Find modulator in system [Section titled “Find modulator in system”](#find-modulator-in-system) Use our guide to [Install DigitalDevices Driver](../../../adapters/dd-driver/). Use the following command to find the adapter number and the modulator device number: ```sh find "/dev/dvb" -name "mod*" ``` The output will display a list of devices in the system: ```plaintext /dev/dvb/adapter0/mod0 /dev/dvb/adapter0/mod1 ``` * `adapter0`: adapter number * `mod1`: device (modulator) number ## Astra settings [Section titled “Astra settings”](#astra-settings) 1. Prepare [MPTS](../../../streams/mpts/) for modulator 2. In the output setting, specify the address: resi://#adapter=0\&device=1 (0 - adapter number, 1 - modulator) 3. In the MPTS NIT settings, configure transponder options  Read more in: [Cable Television with Astra for Hospitality Industry](../../../use-cases/cable-television-with-astra-for-hospitality-industry) ### Additional options [Section titled “Additional options”](#additional-options) * `gain=N`: signal level in range from 0 to 100 * `buffer_size=N`: buffer size in megabytes. Default: `256` * `legacy`: compatibility mode with old RESI modulator for 10 transpodners ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) ### No such file or directory [Section titled “No such file or directory”](#no-such-file-or-directory) If you attempt to find the adapter number and encounter an error: ```plaintext find: ‘/dev/dvb’: No such file or directory ``` it is likely that the DigitalDevices driver is not installed. Please [Install DigitalDevices Driver](../../../adapters/dd-driver/) # TBS6004 DVB-C modulator TBS6004 is a DVB-C 4 QAM modulator PCIe card.  Technical specifications: * 4 modulators on the board * Frequencies: 100 \~ 1000 MHz * Modulation - 16QAM, 32QAM, 64QAM, 128QAM, 256QAM * RF Output Level - 5-120 dBuV ## Setup [Section titled “Setup”](#setup) Use our guide to [Install TBS Driver](../../../adapters/tbs-driver/). Use the following command to find the adapter number and the modulator device number: ```sh find "/dev" -name "mod*" ``` In the output - we will see the numbers of modulators: ```plaintext /dev/tbsmod0/mod1 /dev/tbsmod0/mod0 ``` * `tbsmod0`: adapter number * `mod1`: device number ## Astra settings [Section titled “Astra settings”](#astra-settings) 1. Prepare [MPTS](../../../streams/mpts/) for modulator 2. In the output setting, specify the address: `tbs://#adapter=0&device=1` (0 - adapter number, 1 - modulator) 3. In the MPTS NIT settings, configure transponder options  Read more in: [Cable Television with Astra for Hospitality Industry](../../../use-cases/cable-television-with-astra-for-hospitality-industry) ### Additional options [Section titled “Additional options”](#additional-options) Additional options could be added to the output address: * `bitrate=N`: default value depends on symbolrate and modulation type. For example for symbolrate 6900 and 256-QAM value will be 55 * `gain=N`: signal level in range from 0 to 100. Default value: 60 ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) ### No such file or directory [Section titled “No such file or directory”](#no-such-file-or-directory) If you attempt to find the adapter number and encounter an error: ```plaintext find: ‘/dev/dvb’: No such file or directory ``` it is likely that the TBS driver is not installed. Please [install TBS driver](../../../adapters/tbs-driver/) # HTTP Authorization HTTP authorization controls who can access your protected video content. It ensures only authorized users can watch your streams.  ## Authorization workflow [Section titled “Authorization workflow”](#authorization-workflow) Before configuring authorization in Astra, you need to understand how the process works. 1. **Get channel list from Middleware**  The client sends their login credentials to your Middleware system. If the credentials are valid, the Middleware returns a list of channels the user can access. Each channel includes a unique token for later authorization. 2. **Request channel from Astra**  When the user selects a channel, their video player sends a request to Astra with the unique token from Step 1. 3. **Astra authorizes the request** Astra checks the token against the configured authorization method. If the token is valid, Astra returns the channel stream. If not, it responds with an error. ## Authorization methods [Section titled “Authorization methods”](#authorization-methods) * [User Authorization](../auth-user/): Uses login/password or tokens stored in Astra’s user settings * [HTTP Backend Authorization](../auth-backend/): Sends the token to your Middleware for verification * [Securetoken](../auth-securetoken/): Validates tokens using cryptographic algorithms * [IP Authorization](../auth-ip/): Checks if the user’s IP address is on your access list Choose the method that best fits your security needs and existing infrastructure. # HTTP Auth: Backend Backend authorization lets you use your existing user management system (Middleware) to control access to your streams. Instead of managing users in Astra, you can connect to your current platform like Ministra, IPTVportal, or a custom system. ## How it works [Section titled “How it works”](#how-it-works)  1. **User requests a channel**: The viewer’s player sends a request with their token or credentials 2. **Astra asks your Middleware**: Astra forwards the request details to your user management system 3. **Middleware checks permissions**: Your system verifies if the user can access this channel 4. **Access granted or denied**: If approved, Astra streams the content; if not, access is blocked ## Configuration [Section titled “Configuration”](#configuration) Go to `Settings` → `HTTP Auth` in Astra. Choose your “Backend Type” and enter the “Backend Address” for your system. ### Ministra/Stalker [Section titled “Ministra/Stalker”](#ministrastalker) Backend Address: ```plaintext http://example.com/stalker_portal ``` In your Ministra/Stalker admin panel, enable `Temporary URL` → `Flussonic support` ### IPTVportal [Section titled “IPTVportal”](#iptvportal) **For cloud platform:** ```plaintext https://go.iptvportal.cloud ``` **For local installation:** Use your server’s address (e.g., `http://your-server.com`) In the portal settings open `Keys` menu and create a new key: * `Name`: Astra * `Algorithm`: ARESSTREAM * `Mode`: SM * `Key Length`: 1472 bit * `Update Rate`: 1:00:00 In portal channel settings: * `Auth`: arescrypt * `Encoded`: turn on * `Key`: Astra ### Microimpulse Smarty [Section titled “Microimpulse Smarty”](#microimpulse-smarty) Backend Address: ```plaintext http://example.com ``` ### HTTP Request [Section titled “HTTP Request”](#http-request) Create your own authentication system by selecting `HTTP Request` as the Backend Type and providing your custom endpoint URL. When a user requests access, Astra sends a GET request to your endpoint with: * Query parameters: All parameters from the original user request * HTTP headers with session details: * `X-Session-ID`: unique session number * `X-Channel-ID`: unique channel identifier * `X-Real-IP`: client’s IP address * `X-Real-Path`: client’s request path * `X-Real-UA`: client’s User-Agent * `X-Real-Host`: client’s Host request Your backend can respond with: * `HTTP 200`: Access granted * `HTTP 403/401`: Access denied * `X-Session-Name` header - User’s login name (optional) **Example workflow:** 1. Your backend: `https://auth.example.com/check` 2. User requests: `https://live.example.com/play/a001/index.m3u8?token=123` 3. Astra calls: `https://auth.example.com/check?token=123` 4. Headers include: `X-Real-Path: /play/a001/index.m3u8` plus other request details ## Important: Default behavior [Section titled “Important: Default behavior”](#important-default-behavior) If your backend is unreachable, Astra allows access by default. This prevents your service from going down if your authentication server has issues, but means users get free access during outages. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) ### Users getting free access [Section titled “Users getting free access”](#users-getting-free-access) If users can watch channels without paying, your backend might be down. Test your backend connection: ```sh curl -v "https://auth.example.com/check" ``` Replace the URL with your actual backend address from Astra settings. **Common issues:** * `Connection refused`: Backend server is down * Request hangs: Network connectivity problems * Wrong URL: Check your backend address in settings ### Users can’t access paid channels [Section titled “Users can’t access paid channels”](#users-cant-access-paid-channels) If legitimate users are blocked: 1. Check your backend logs: Look for authentication errors 2. Verify response codes: Your backend must return HTTP 200 for valid users 3. Test manually: Use curl with a valid token to test your endpoint # HTTP Auth: IP IP Authorization compares the requests IP address with the predetermined list of IP addresses. Access to the content will be granted only for allowed IP addresses.  ## Global IP list [Section titled “Global IP list”](#global-ip-list) Global IP list available in Settings → HTTP Auth  In this list you can define single IPv4 addresses and IPv4 network address in CIDR notation. ## User IP settings [Section titled “User IP settings”](#user-ip-settings) In the user settings you can define IPv4 address. In this case session could be linked to the user. # HTTP Auth: Securetoken Middleware generates an unique token for every channel with crypto algorithms and with securetoken. To the each channel address Middleware appends information when access granted, expiration time, and token to validate provided data. Astra uses same crypto algorithms and same securetoken to verify provided data and grant access to the channel. ## Token [Section titled “Token”](#token) Temporary token calculated by the middleware on the server side when client requests playlist. Token contains next parts: 1. Hash - hash calculated on the server with SHA1 algorithm 2. Salt - random word for better secure 3. End time - token expiration time in the unix-timestamp format 4. Start time - token creation time in the unix-timestamp format All parts should be separated by minus sign and addedd to the channels address. For example: `https://example.com:8100/tv/travel-channel/index.m3u8?token=e8bff06f373694dda657e8417fe76f6b54b69807-a5cd6c00-1669890000-1669810000` ## Hash [Section titled “Hash”](#hash) Hash should be calculated on middleware with SHA1 algorithm from string concatenated from next parts: * Channel ID - unique channel identifier from Astra settings * Client IP address * Start time - unix-timestamp as decimal number * End time - unix-timestamp as decimal number * Securetoke - defined in the Astra settings * Salt - random word for better secure ## Example on PHP [Section titled “Example on PHP”](#example-on-php) Create a file `securetoken.php` with the following code: ```php HLS -> Use Expires header # HLS Segmenter HLS (HTTP Live Streaming) one of the most popular media streaming protocol. It is designed to transmit audio and video data over HTTP from a server to clients. Media content could be distributed with Content Delivery Networks (CDN) to enchance availability. In pair with dynamic, adaptable streaming HLS provides highest quality in varying network conditions.  The HLS Segmenter is Astra feature to split continuous media stream into HLS segments. To provide access to HLS segments Astra generates HLS Media Playlist. Astra specifically functions as the HLS segmenter. Other features such as transcoding and caching require additional software. For instance, FFmpeg is recommended for transcoding, while Nginx could be used for caching. ## HLS Segmenter Options [Section titled “HLS Segmenter Options”](#hls-segmenter-options) In Astra Web Interface HLS options available in Settings → HLS  * **Duration**: duration of the HLS segment in seconds. Default: 3 * **Quantity**: number of segments in one HLS Media Playlist. Default setting is 4 ### Segment naming [Section titled “Segment naming”](#segment-naming) Method of generation file name for HLS Segments * **PCR-hash**: default value. Secure variant, Astra uses timestamp from stream for file name * **Sequence**: sequential number as file name ### Resource path [Section titled “Resource path”](#resource-path) The resource path let choose path to the resources in the HLS Media Playlist: * **Absolute**: default value. URL with origin and full path to the resource. For example: `https://example.com/play/channel-id/segment-001.ts` * **Relative**: relative path to the resource. For example: `segment-001.ts` * **Full**: full path to the resource. For example: `/play/channel-id/segment-001.ts` ### Other options [Section titled “Other options”](#other-options) * **Round duration value**: this function rounds the duration of media stream segments to integer values (not recommended) * **Use Expires header**: this option adds the Expires header to the HTTP response. This header is necessary for the caching proxies. Read more in [HLS Caching Proxy with Nginx](../hls-caching-proxy-with-nginx/) * **Pass all data PIDs**: by default, only video and audio packets writes to the HLS segments. This option allow to write all Data packets. ### HLS Media Playlist [Section titled “HLS Media Playlist”](#hls-media-playlist) * **Use default headers for .m3u8**: with this option Astra appends HTTP headers to the response with HLS Media Playlist for Cross-Origin Resource Sharing. Enabled by the default ### HLS Segments [Section titled “HLS Segments”](#hls-segments) * **TS Extension**: this option allows to customize file extension for HLS Segments. Default is `ts` * **TS mime type**: this option allows to customize MIME type for HLS Segments. Default is `video/MP2T` * **Use default headers for .ts**: with this option Astra appends HTTP headers to the response with HLS Segment for Cross-Origin Resource Sharing. Enabled by the default # HTTP Play HTTP Play - is a convenient and efficient way to access all your channels with just one click. With HTTP Play, you can easily stream channels by their ID using either the HTTP MPEG-TS or HLS protocols. This feature simplifies the streaming process, providing seamless access to your channels and enhancing the overall user experience. By the default HTTP Play is disabled. To activate it open: Settings → HTTP Play.  * **Allow HTTP access to all streams**: this option allows to enable access to the channels with HTTP MPEG-TS protocol * **Allow HLS access to all streams**: this option allows to enable access to the channels with HLS protocol Caution HLS Protocol turns off starting streams on demand and channels will works permanently. Also HLS Protocol use a lot of RAM, about 4Mb per 1Mbit * **HTTP play port**: parameter allows you to assign a port that will be used to transfer the playlist and media streams. It is used to separate the web interface and the playlist * **Disable TLS on HTTP Play port**: this setting disables the use of HTTPS for this media playlist * **Path to TV logos**: the parameter is used to specify the path to the directory with logo files * **Custom name for playlist**: the parameter renames `playlist.m3u8` to an arbitrary name * **Playlist arrange**: this option allows to select a category for grouping channels. You may configure groups in the Settings → Groups * **playlist.m3u8**: this is a link to the channels playlist. You may use playlist on the mobile devices, computer, TV, or Set-top-Box. You may append authentication details to the playlist, for example `https://your-server/playlist.m3u8?token=xxx`. [Read more](../playlist/) Caution By default, access authentication is disabled. Without authentication, access to the channels is not restricted, allowing anyone to potentially gain access to the content. To restrict access to your channels, please consider enabling Access Authorization or utilizing a System Firewall to limit access to your server. This will help ensure that your content remains secure and accessible only to authorized users. ## Channel Logo [Section titled “Channel Logo”](#channel-logo) By adding logos to your channel playlists, you provide your viewers with a more visually appealing and user-friendly experience. Logos help users quickly identify their favorite channels and make browsing through the playlist more efficient. With the “Path to TV logos” option, you can specify the location of the images directory on your server. Astra loads images with the same name as the channel name and appends the logo to the playlist information. 1. Create a directory: `/var/lib/astra/tvg-logo` 2. In the `Path to TV logos`, set the full path to this directory: `/var/lib/astra/tvg-logo` 3. Save channel logos to the directory. Use the same file name as the channel name. For example: `Travel Channel.png` # TLS certificate for HTTPS TLS certificate is required to enable HTTPS for the Astra web interface and media delivery. The certificate is used to encrypt the data transmitted between the server and the client, ensuring secure communication. ## Configuration [Section titled “Configuration”](#configuration) You can obtain a TLS certificate with [acme.sh](https://acme.sh) for free. In the Astra web interface, navigate to `Settings` → `General` → `HTTP Server` and set paths to the certificate and private key files.  The option `Disable TLS for primary port` allows you to disable HTTPS for web interface and API. ## HTTP Play [Section titled “HTTP Play”](#http-play) Once you turn on HTTPS, it will be enabled for the HTTP Play as well. To disable HTTPS for HTTP Play, you can use the option `Disable TLS on HTTP Play port` in the `Settings` → `HTTP Play`.  ## Output settings [Section titled “Output settings”](#output-settings) If you configure HTTP manually, you can use `https://0:443/custom-path` as the output URL. # Playlist for HTTP Play Astra generate simple playlist with links to all enabled channels. This playlist available only for [HTTP Play](../http-play/) feature.  ## Playlist format [Section titled “Playlist format”](#playlist-format) Astra provide access to playlist in next formats: * `M3U8` - is a most popular format supported by all media players * `XSPF` - is an XML-based playlist format, supported by some players In this guide we will use M3U8 format. ## Links to the playlist [Section titled “Links to the playlist”](#links-to-the-playlist) Default link to the M3U8 playlist is: ```plaintext http://example.com:8000/playlist.m3u8 ``` Where: * `example.com` - your server IP address * `8000` - is a port to HTTP Play, by default it equal to the Astra Web Interface port, but could be customized in the HTTP Play settings * `playlist.m3u8` - playlist file name, also could be customized in the HTTP Play settings ## Channel Groups [Section titled “Channel Groups”](#channel-groups) For better navigation channels in playlist could be grouped. To do that create new category in the Settings → Groups. Read more how to create [Channel Groups](../../../settings/groups/). Then select created category in the `HTTP Play` settings, option `Playlist Arrange`. Note Some players, like VLC, doesn’t support M3U8 groups and shows flat playlist ## Channel Logos [Section titled “Channel Logos”](#channel-logos) Some players and middleware solutions display channel logos alongside their names in the channels list.  To begin, download archive with logo images from: You may download and extract archive on your server using the following commands: ```sh mkdir -p /var/lib/astra cd /var/lib/astra curl -LO http://epg.one/epgone_transparent_logo.zip unzip it999_transparent_logo.zip rm it999_transparent_logo.zip ``` In the Settings → `HTTP Play` → `Path to TV logos`, set the path as `/var/lib/astra/it999_transparent_220x132`. Please, note the directory name is for example above. The provided archive includes logos in PNG format, with filenames matching the channel names. With these steps completed, the playlist will now include the `tvg-logo` option for each channel. ## Electronic Program Guide [Section titled “Electronic Program Guide”](#electronic-program-guide) Some players and middleware solutions display current and upcoming events for channels. The Electronic Program Guide (EPG) can be exported to the player in XMLTV or any other format supported by the player. In the Astra Settings → `HTTP Play` → `M3U Header`, set option ```plaintext url-tvg="https://teleguide.info/download/new3/xmltv.xml.gz" ``` Line will be added to the playlist header and provide information about EPG location. This URL is just an example, you can use any other EPG source or explore our solution, [EPG Aggregator](../../../streams/spts/epg/#epg-aggregator). The final step is a configuring channel ID to link your channels with EPG records. Each channel in the XMLTV has unique identifier, like so: ```xml Discovery Channel ``` In Astra, navigate to the Channel settings, open EPG tab, and set the `XMLTV Channel ID` value to `226`:  # SRT for Digital TV delivery SRT (Secure Reliable Transport) is an open-source video transport protocol that optimizes streaming performance across unpredictable networks, such as the internet. It is designed to deliver high-quality, low-latency video streams while ensuring security and reliability. # UDP / RTP for Digital TV delivery UDP multicast delivers TV content to many receivers at once using a single stream. This saves bandwidth and works well for hotels, ISP networks, and sports venues. Read more about the [UDP Protocol](./protocol/).  ## Media Address Format [Section titled “Media Address Format”](#media-address-format) Media Address configure the destination of the UDP stream. The format for this address is as follows: ```plaintext udp://[interface@]address[:port][#options] ``` In square bracket optional parameters. * `interface` - local interface name, such as `eth0`. If this field is not defined, the UDP stream will be delivered according to the system routes * `address` - IPv4 address of the multicast group, localhost, or remote host for unicast delivery * `port` - network port for UDP delivery. If not specified, the default port `1234` is used Additional options can be defined after the `#` symbol and are separated by the `&` symbol, similar to the parameters in a typical URL. Here are the available options: * `socket_size=bytes` - defines custom size of the system socket. If not specified, the default value is taken from the system configuration: `sysctl net.core.wmem_default` * `sync` - enables the transmission of UDP in a separate thread with bitrate syncing * `no_sync` - disable bitrate syncing if it has been enabled globally * `cbr=Kbps` - enables bitrate syncing and constant bitrate. Read more on [Constant Bitrate (CBR)](./cbr/) * `ttl=n` - controls the lifetime of the datagram to prevent it from looping indefinitely due to routing errors. The default value is `32` * `sap` - turn on SAP. Read more on [Session Announcement Protocol for Multicast](./sap/) Here are some examples of how the media address format can be used in different scenarios with Astra: * Multicast delivery on a specific interface: If you want to deliver a UDP stream to a multicast group at the address `239.255.0.1` via a specific network interface like `eth0`, the address would look like this: `udp://eth0@239.255.0.1` * Multicast delivery on system-defined route: If you want to deliver a UDP stream to a multicast group at the address `239.255.0.2` and you want the system to determine the route (interface), the address would be: `udp://239.255.0.2` * Unicast delivery to a specific host: If you’re sending a unicast stream to a specific host at the IP address `192.168.1.100`, the address would look like this: `udp://192.168.1.100` * Delivery on a specific port: If you want to deliver a UDP stream to a multicast group at the address `239.255.0.3` on a specific port, say `5000`, the address would be: `udp://239.255.0.3:5000` * Turn on CBR to prepare stream for DVB modulation: If you want to deliver a UDP stream to the DVB modulator, you may needed constant bitrate, say `24000Kbit/s`, the address would be: `udp://239.255.0.4#cbr=24000` * Localhost Delivery with a Specific Port: If you need to deliver a UDP stream to a service on the same server, such as FFMpeg for transcoding, you would use the following address: `udp://127.0.0.1:11000` ## Web Interface [Section titled “Web Interface”](#web-interface) To configure a new UDP output using the Web Interface, begin by selecting “New Stream” from the main menu. Then, in the Output List, click on the gear icon and set the “Output Type” to UDP. Alternatively, you can modify an existing stream by opening its settings, adding a New Output, and clicking on the corresponding gear icon.  Most options presented in the web interface correspond directly to the components of the UDP address, as described in the “Media Address Format” section. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) # Constant Bitrate (CBR) Constant Bitrate (CBR) is a method of filling bitrate gaps with null packets to achieve a constant rate, which is required for DVB modulators. The diagram below shows a stream without CBR, where bitrate varies and has gaps:  When CBR is enabled, the stream is filled with null packets to maintain a constant bitrate, as shown in the diagram below:  ## How to configure CBR [Section titled “How to configure CBR”](#how-to-configure-cbr) To configure CBR in Astra, you need to add the `cbr` parameter to your UDP output address. The `cbr` parameter is only available for UDP outputs. For example: `udp://239.255.1.1#cbr=4000` This will enable CBR with a target bitrate of 4000 Kbps. You can adjust the bitrate value according to your requirements. Note CBR doesn’t reduce bitrate. If your stream’s bitrate exceeds the CBR limit, all excess packets will be dropped. ## How to reduce bitrate [Section titled “How to reduce bitrate”](#how-to-reduce-bitrate) The cbr option in Astra does not reduce the stream’s bitrate. It only fills bitrate gaps with null packets to achieve a constant rate. To actually reduce the bitrate, you need to transcode the stream. This can be done using a tool like [Senta](https://senta.tv) or FFmpeg. # UDP Protocol Overview UDP (User Datagram Protocol) is a network protocol for local networks and the Internet. It offers low latency but does not guarantee delivery. UDP uses checksums for data integrity and port numbers to identify applications. For more details, see the [RFC768](https://www.rfc-editor.org/rfc/rfc768) standard. ## Multicast [Section titled “Multicast”](#multicast) Multicast sends data to multiple receivers at once. The network delivers a single copy of the data to all subscribers in the group. This saves bandwidth and makes multicast ideal for Digital TV streaming.  ## Broadcast [Section titled “Broadcast”](#broadcast) Broadcast sends data to all devices on the network. **Never use it for Digital TV** - it creates unnecessary traffic on devices that don’t need the stream. ## Unicast [Section titled “Unicast”](#unicast) Unicast sends data from one sender to one receiver. It is used in protocols like RTSP and SRT. Unicast also works for transmitting Digital TV between services on the same server or local network - for example, from a receiver to a transcoder, then to an HLS segmenter. # SAP for Multicast Session Announcement Protocol (SAP) is a protocol to announce available Multicast streams in local networks. Clients on the network listens for announces and receives information such: * Stream name * Multicast address and port * TTL * Stream format - RTP or UDP Astra send SAP packets to the multicast group 239.255.255.255 port 9875. ## Configure Astra [Section titled “Configure Astra”](#configure-astra) In the Output address append `sap` option to turn the SAP announcements on.  ## Receiving SAP with VLC [Section titled “Receiving SAP with VLC”](#receiving-sap-with-vlc) Open VLC Media Player and in the Playlist select Local Network → Network streams (SAP). VLC receives SAP announcements and list all available streams. Double click on the stream to start playing. # Logs in Astra Logs help you troubleshoot streaming issues, monitor service health, and understand what happens with your streams. Astra groups log messages by severity: * **error**: Critical problems that stop stream input or break functionality * **warning**: Stream issues that might affect playback quality or cause problems * **info**: Normal service events like startup, shutdown, version information, or stream activation * **debug**: Detailed technical information about stream processing. Disabled by default. Enable in log settings or with `--debug` command line option * [HTTP Access Log](./access-log/): Records all requests to Astra’s HTTP server in a separate file ## Web Interface [Section titled “Web Interface”](#web-interface) Open logs in the web interface by clicking **Log** in the main menu:  * **Search**: Filter messages to find specific errors or events quickly * **Settings**: Control what information gets logged * **Clear**: Remove messages from view. Actual log files on the server are not affected ## Log Settings [Section titled “Log Settings”](#log-settings) Change what gets logged in **Log** → **Settings**:  * **API Access**: Record every API request to track who makes changes to your service * **Debug**: Record detailed technical information about stream processing to diagnose complex issues ## Log File Location [Section titled “Log File Location”](#log-file-location) Where Astra writes logs depends on how you started the service: * Standard service setup with `astra init`: logs go to `/var/log/astra.log` * Custom service setup with `astra init `: logs go to `/var/log/.log` * Console mode: logs appear only in the console output ## Log Rotation [Section titled “Log Rotation”](#log-rotation) Astra manages log file size automatically. When a log file reaches 2MB, Astra creates a new file and keeps one previous version as backup. ## Common Messages [Section titled “Common Messages”](#common-messages) You may find these articles helpful for understanding common log messages: * [ERROR: CC](../troubleshooting/stream/cc-error/) - packets loss or excess in MPEG-TS streams * [ERROR: PES](../troubleshooting/stream/pes-error/) - corrupted PES packets in MPEG-TS streams # HTTP Access Log in Astra HTTP Access Logs record every request to Astra’s built-in HTTP server. Use them to track who accesses your streams, diagnose playback issues, or monitor traffic patterns. Access logs are disabled by default. Enable access logs in **Settings** → **General** → **HTTP Server**: **HTTP Access Log**: Full path where logs are saved, for example `/var/log/astra-access.log` ## Example Log Entries [Section titled “Example Log Entries”](#example-log-entries) ```plaintext 192.168.88.100 - - [11/Aug/2023:07:03:07 +0000] "GET / HTTP/1.1" 200 0 192.168.88.100 - admin [11/Aug/2023:07:03:07 +0000] "POST /control/ HTTP/1.1" 200 0 198.51.100.1 - - [11/Aug/2023:07:03:08 +0000] "GET /play/a0g2/71545838.m3u8 HTTP/1.1" 200 0 198.51.100.1 - - [11/Aug/2023:07:03:08 +0000] "GET /play/a0g2/113900585_92b9.ts HTTP/1.1" 200 0 ``` Each line follows the standard HTTP server format: ```plaintext remote_addr - remote_user [time] "request" status bytes_sent ``` * **remote\_addr**: IP address of the client making the request * **remote\_user**: Username if authentication was used, otherwise shown as `-` * **time**: When the request was received * **request**: HTTP method, requested URL, and protocol version * **status**: HTTP response code (200 for success, 404 for not found, etc.) * **bytes\_sent**: Amount of data sent in the response ## Log Rotation [Section titled “Log Rotation”](#log-rotation) Access logs grow over time and can fill your disk. Use log rotation to automatically archive old logs and free up space. Linux systems use `logrotate` to handle this. Create a configuration file at `/etc/logrotate.d/astra-access-log`: ```plaintext /var/log/astra-access.log { daily rotate 10 missingok notifempty compress delaycompress sharedscripts postrotate systemctl reload astra || true endscript } ``` Configuration options: * **daily**: Rotate logs every day * **rotate 10**: Keep the last 10 archived files * **missingok**: Don’t report errors if the log file doesn’t exist * **notifempty**: Skip rotation if the log file is empty * **compress**: Compress old log files with gzip to save disk space * **delaycompress**: Wait one rotation cycle before compressing to avoid losing recent messages * **sharedscripts**: Run the postrotate script only once, even with multiple log files * **postrotate**: Command that runs after rotation. Reloads Astra so it starts writing to the new log file # Export Monitoring Events Astra allows you to export monitoring events with the status of incoming streams or DVB-adapters. ## Monitoring URL [Section titled “Monitoring URL”](#monitoring-url) The address of the monitoring server can be specified in the web interface: Settings → General → Monitoring:  Address has the following parameters: * `interval=30` - this parameter defines the interval for transmitting statistics, measured in seconds. The default value for this parameter is 30. * `total=1` - this parameter is used to obtain summary statistics from the data packet For example with address `http://example.com/api#interval=60&total=1` astra sends HTTP POST request to the `http://example.com/api` every minute, request containing JSON with summary statistics for one minute of stream monitoring. ## Stream Properties [Section titled “Stream Properties”](#stream-properties) Stream properties Astra send only once on stream startup. ```json [ { "channel": { "type": "spts", "name": "Channel Name", "id": "a002", ... }, "timestamp": 1677687308, "hostname": "astra" } ] ``` * `channel` - whole stream configuration * `timestamp` - event time * `hostname` - server hostname ## Stream Status [Section titled “Stream Status”](#stream-status) ```json [ { "count": 0, "timestamp": 1677687310, "channel_id": "a002", "input_id": 1, "current": true, "onair": false, "scrambled": false, "bitrate": 3013, "packets": 2005, "cc_error": 0, "sc_error": 0, "pes_error": 0, "pcr_error": 15 } ] ``` This list describes the parameters that provide information about the stream workflow: * `count` - only for summary data, provide an amount of seconds that has elapsed since the last collection of statistics * `timestamp` - event time in Unix format * `channel_id` - unique ID of the channel * `input_id` - the input number. Starts with 1 * `current` - indicates that statistics for current active input * `onair` - stream status, providing a quick way to check if it’s running * `scrambled` - indicates whether the stream is encrypted or not * `bitrate` - input bitrate in Kbit/s * `packets` - total number of TS packets * `cc_error` - total number of occured CC errors * `pes_error` - total number of occured PES errors This data is transmitted in JSON format as an array of several elements, with each element representing one second of observations. The number of elements in the array is determined by the frequency of statistics transmission. If statistics aggregation is enabled, then there is only one element in the array, which contains the total number of errors and the average bitrate for the period equal to the statistics transmission frequency. ## Adapter Properties [Section titled “Adapter Properties”](#adapter-properties) Adapter properties Astra send only once on adapter startup. ```json [ { "dvb": { "name": "11034V @ 13E", "id": "a001", .... }, "timestamp": 1677687308, "hostname": "astra" } ] ``` * `dvb` — while adapter configuration * `timestamp` — event time * `hostname` — server hostname ## Adapter Status [Section titled “Adapter Status”](#adapter-status) ```json [ { "dvb_id": "a0dj", "timestamp": 1677687310, "status": 31, "signal": 76, "signal_db": -2488, "snr": 60, "snr_db": 902, "unc": 0, "ber": 0, "bitrate": 1938 } ] ``` This list describes the parameters that provide information about the adapter workflow: * `dvb_id` - unique ID of the adapter * `timestamp` - event time * `status` - signal status * `signal` - approximate signal level in percent * `signal_db` - signal level in `dBm * 100` * `snr` - approximate signal to noise ratio in percent * `snr_db` - signal to noise ratio in `dB * 100` * `ber` - bit errors counter * `unc` - block errors counter * `bitrate` - total bitrate in Kbit/s Signal status describe the state of the tuner, described in 5-bit number: * `SIGNAL` — the signal bit will be set when the tuner captures the signal * `CARRIER` — stable signal reception * `FEC` — reception FEC (forward error correction) data * `SYNC` — received information for synchronization * `LOCK` — the tuner is set to receive a signal. If the tuner configured successfully and signal is locked, the status parameter will be set to 31 # Integration Astra with Grafana Grafana is an open source analytics and interactive visualization web application. It works in pair with [InfluxDB](../influxdb/) to visualize status of the Astra, stream, and adapters. ## Install [Section titled “Install”](#install) Before Grafana installation, make sure that InfluxDB installed and configured: [Read more…](../influxdb/) Download latest version from 1. Go to Grafana site: 2. Choose latest version 3. Choose your platform 4. Launch commands from the instruction on the Grafana site Find out more information on official site: ## Grafana configuration [Section titled “Grafana configuration”](#grafana-configuration) 1. Open Grafana Admin interface: `http://grafana-server:3000` 2. On the login page, enter `admin` for username and password 3. Set new password ## Append data source [Section titled “Append data source”](#append-data-source) Open Settings → Data Sources and click “Append data source”, choose InfluxDB and set next options: * Name: `Astra` or any other * Query language: **Flux** * HTTP URL: `http://db-server:8086` * Turn off **Basic auth** * Organization: your organization name in InfluxDB Settings * Token: your token copied for Astra settings * Min time interval: `1m` Click **Save & Test**, you should see green notification: **Bucket found** ## Append dashboard [Section titled “Append dashboard”](#append-dashboard) 1. Download our template for Grafana: [dashboard.json](https://cdn.cesbo.com/astra/grafana/dashboard.json) 2. Open: Create → Import 3. Click **Upload JSON file** 4. Choose downloaded file 5. Set any name for dashboard 6. Click **Import** ## Dashboard [Section titled “Dashboard”](#dashboard)  Dashboard has next variables: * **Source**: choose **Astra** or other name; * **Bucket**: this is database name in the InfluxDB. Same as **Instance Name** in the Astra settings. If you have several servers or different Astra instances on the same server you can create several dashboards for each instance; * **Adapter**: All DVB adapters on the instance; * **Stream**: All streams on the instance. ### Status panels [Section titled “Status panels”](#status-panels) CPU Usage: * The System CPU usage is for all available cores. Max value is a number of cores multiplied by 100 * The App CPU usage is for all threads on all cores and relative to the System CPU usage Memory Usage: * The System Memory Usage - is total memory usage by all processes in the system * The App Memory Usage - is total memory usage by all app threads. Value is relative to the system memory usage Status: * **App uptime**: elapsed time since app launched * **Sys uptime**: elapsed time since system startup * **LA 1m**: load average for 1 minute * **LA 5m**: load average for 5 minutes * **LA 15m**: load average for 15 minutes Failed Streams - list of all incidents ordered by the time. Recent events on top of the table. All values in the table at the event time: * **Name**: stream name * **Elapsed time**: time since incidents happened * **Sessions**: number of HTTP/HLS sessions * **CC Errors**: counter of the detected packet loss events * **Sync Errors**: counter of the HTTP/HLS bitrate synchronization errors * **PES Errors**: percent of the video/audio packets with the corrupted content * **Scrambled**: percent of the scrambled packets * **Bitrate**: stream bitrate in KBit/s Adapters and streams:  Charts displayed separately for each selected adapter or streams. # Integration Astra with InfluxDB InfluxDB is an open-source time series database. ## Install [Section titled “Install”](#install) Download latest version from 1. Go to InfluxDB site: 2. Choose latest version 3. Choose your platform 4. Launch commands from the instruction on the InfluxDB site Find out more information on official site: InfluxDB is an open-source time series database. ## InfluxDB Configuration [Section titled “InfluxDB Configuration”](#influxdb-configuration) Open the InfluxDB Admin interface at `http://db-server:8086`. First, create a new bucket. A bucket serves as storage for all data received from Astra. You can find buckets in the left sidebar under the “Load Data” group. To create a new bucket: 1. Click **Create Bucket** 2. Set the bucket name, for example, `astra` 3. Set data retention: in the **Delete Data** section, select **Older than** and choose 30 days or any other value you prefer. The next step is to grant Astra access to the bucket. In the left sidebar under the `Load Data` group, open `API Tokens`: 1. Click **Generate API Token** and choose **Custom API Token.** 2. Set the token description as `astra` 3. In the Bucket group, set Read and Write permissions for the `astra` bucket. 4. Click **Generate** Now, InfluxDB is configured and ready to receive data. ## Astra Configuration [Section titled “Astra Configuration”](#astra-configuration) Open Settings → General in the Astra Web Interface. Set options for InfluxDB configuration: * **Instance Name**: by the default is `astra` will be used as bucket in the InfluxDB * **InfluxDB Address**: address of the InfluxDB: `http://db-server:8086` * **InfluxDB Organization**: your orgranization in the InfluxDB settings * **InfluxDB Token**: paste your token generated on previous step * Click “Apply & Restart” ## InfluxDB data structure [Section titled “InfluxDB data structure”](#influxdb-data-structure) ### Stream [Section titled “Stream”](#stream) Measurement: `stream` Tags: * `id` - unique stream identifier * `name` - stream name Data: * `active` - `true` if stream is active, or `false` if stream work on demand and inactive * `onair` - `true` if active input works without errors * `sessions` - uint, number of sessions * `bitrate` - uint, stream bitrate in KBit/s * `sc_error` - uint, percent of scrambled TS-packets * `cc_error` - uint, CC errors counter * `pes_error` - uint, percent of invalid PES-packets * `sync_error` - uint, HTTP/HLS sync errors ### Adapter [Section titled “Adapter”](#adapter) Measurement: `adapter` Tags: * `id` - unique adapter identifier * `name` - adapter name Data: * `lock` - boolean, `true` if tuner has lock and able to receive data * `signal` - uint, approximate signal level in percent * `signal_db` - float, signal level in dBm * `snr` - uint, approximate signal to noise ratio in percent * `snr_db` - float, signal to noise ratio in dB * `ber` - uint, bit errors counter * `unc` - uint, block errors counter * `bitrate` - total bitrate in Kbit/s ### System information [Section titled “System information”](#system-information) Measurement: `sysinfo` Data: * `la1` - float, load average for 1 minute * `la5` - float, load average for 5 minutes * `la15` - float, load average for 15 minutes * `threads` - uint, number of the threads * `sys_cpu` - uint, total CPU usage. Could be up to: 100 multiplied with the core numbers on all CPUs * `app_cpu` - uint, CPU usage by the process and all threads * `sys_mem` - uint, total RAM usage * `app_mem` - uint, RAM usage by the process and all threads * `app_mem_kb` - uint, RAM usage by the process and all threads in kilobytes * `sys_uptime` - uint, total system uptime in seconds * `app_uptime` - uint, process uptime in seconds # Integration Astra with Zabbix Zabbix is an open-source platform for monitoring network services, servers, and applications. It can be integrated with Astra to monitor Streams and DVB Adapters. Note Available for Astra versions released after 2021-05-11 ## Zabbix Server installation [Section titled “Zabbix Server installation”](#zabbix-server-installation) Zabbix can be installed both on a dedicated server and on an Astra server 1. Go to 2. Select Zabbix version 3. Select your OS 4. Follow the installation instructions You can find detailed information on [Zabbix Manuals](https://www.zabbix.com/manuals) ## Zabbix Agent installation [Section titled “Zabbix Agent installation”](#zabbix-agent-installation) Install Zabbix Agent on the server with Astra. 1. Go to 2. Select your OS 3. Follow the installation instructions You can find detailed information on [Zabbix Agent Manuals](https://www.zabbix.com/documentation/current/manual/concepts/agent) ## Zabbix Agent configuration [Section titled “Zabbix Agent configuration”](#zabbix-agent-configuration) First of all Zabbix Agent should be configured to allow incoming connections from the Zabbix Server. Open the Agent configuration file located in `/etc/zabbix/zabbix_agentd.conf` with your favorite editor. 1. Find the `Server=` option and set the IP address or hostname of the server with Zabbix Server; 2. Find the `UnsafeUserParameters=` option or append new and set value to `1`. Save file. Zabbix Agent receives all information from Astra with scripts writed on Python. Make sure that on your server installed Python3: ```sh sudo apt install python3 python3-pip ``` for RPM-based system use `yum` instead of `apt`. Next install necessary library for Python: ```sh pip3 install requests ``` Download scripts for Zabbix Agent: ```sh curl https://cdn.cesbo.com/astra/zabbix/agent.tar.gz | tar -zxC /opt ``` Scripts will be saved to the `/opt/zabbix_agent` directory. Download service configuration file for Zabbix Agent: ```sh curl -o /etc/zabbix/zabbix_agentd.d/astra.conf https://cdn.cesbo.com/astra/zabbix/astra.conf ``` And finally restart Zabbix Agent: ```sh systemctl restart zabbix-agent ``` ## Install Zabbix Template for Astra [Section titled “Install Zabbix Template for Astra”](#install-zabbix-template-for-astra) Note For Zabbix 7.4, the menu section for templates and hosts is called **Data collection** instead of **Configuration** as it was in Zabbix 6.0. Download the [Template](https://cdn.cesbo.com/astra/zabbix/zbx_astra.xml) to your computer and import this file to Zabbix: In Zabbix web interface open **Configuration** → **Templates**, then click the **Import** button in the upper right corner. Click **Browse** and select the template file, then click **Import** button. After successful import, you will see a green message **Imported successfully** ## Configure Template [Section titled “Configure Template”](#configure-template) In Zabbix web interface open **Configuration** → **Templates**, then select **Astra API monitoring** and open the Macros tab. Fill next values: * First line, set administrator password to Astra web interface * Second line, set administrator username to Astra web interface * The last line, the port of the Astra web interface. If you have multiple processes, specify all ports separated by commas. For example: `8000,8001,8002` Click `Update` button to apply changes  ## Connect Zabbix to Astra [Section titled “Connect Zabbix to Astra”](#connect-zabbix-to-astra) In Zabbix web interface open **Configuration** → **Hosts** and click **Create host** in the top right corner. Fill following fields: * **Host name**: any name of the server where Astra is installed, for example: Astra * **Templates**: select **Astra API monitoring** and optionally **Linux by Zabbix agent** to monitor general system state * **Groups**: select **Cesbo\_templates** or create a new group * **Interfaces**: click **Add**, select **Agent**, and specify the IP address or hostname of the server where Astra and Zabbix Agent are running. Port should be `10050` by default  Save changes. ## Viewing Graphs [Section titled “Viewing Graphs”](#viewing-graphs) After about 10 minutes, graphs will appear showing channel and adapter status. To view them: 1. In Zabbix web interface, open **Monitoring** → **Hosts** 2. Find your Astra host in the list 3. Click **Graphs** in the host row to see available monitoring graphs 4. Select a graph to view detailed statistics Alternatively, you can view data in **Monitoring** → **Latest data** to see current values and short-term history for all monitored items. ## Graphs Examples [Section titled “Graphs Examples”](#graphs-examples)   # Privacy Statement *Last updated: Nov 27, 2025* This privacy policy of Cesbo OÜ (registry number: 14226966, address: Mooni 18, 10613, Tallinn, Estonia, hereinafter “Cesbo”) (hereinafter the “Privacy Policy”) regulates the use and processing of all data and information disclosed to Cesbo while using the website cesbo.com, its subpages, its software, and its services (hereinafter the “Services”). By using the Cesbo Services the user consents to adhere to this Privacy Policy. Below we explain how we collect, use, and share information about you, along with the choices that you have with respect to that information. ## Information We Collect [Section titled “Information We Collect”](#information-we-collect) We only collect information about you if we have a reason to do so-for example, to provide our Services, to communicate with you, or to make our Services better. We collect information in two ways: if and when you provide information to us and automatically through operating our Services. Let’s go over the information that we collect. ### Information You Provide to Us [Section titled “Information You Provide to Us”](#information-you-provide-to-us) It’s probably no surprise that we collect information that you provide to us. The amount and type of information depends on the context and how we use the information. Here are some examples: * **Basic Account Information**: We ask email address to set up your account * **Transaction and Billing Information**: If you buy something from us you will provide additional personal and payment information that is required to process the transaction and your payment, such as your name and contact information * **Credentials**: Depending on the Services you use, you may provide us with credentials for your server (like SSH username and password) * **Communications With Us**: You may also provide us information when you respond to surveys or communicate with our team about a support question ### Information We Collect Automatically [Section titled “Information We Collect Automatically”](#information-we-collect-automatically) We also collect some information automatically: * **Log Information**: Like most online service providers, we collect information that web browsers, mobile devices, and servers typically make available, such as the browser type, IP address, unique device identifiers, language preference, referring site, the date and time of access, operating system, and mobile network information. We collect log information when you use our Services * **Usage Information**: We collect information about your usage of our Services. For example, we collect information about the pages you visit or site parts that you check the most. We use this information to, for example, provide our Services to you, as well as get insights on how people use our Services, so we can make our Services better * **Location Information**: We may determine the approximate location of your device from your IP address. We collect and use this information to, for example, calculate how many people visit our Services from certain geographic regions * **Information from Cookies**: A cookie is a string of information that a website stores on a visitor’s computer, and that the visitor’s browser provides to the website each time the visitor returns ## Purposes for Using Information [Section titled “Purposes for Using Information”](#purposes-for-using-information) We use information about you as mentioned above and for the purposes listed below: * To provide our Services. For example, to set up and maintain your account or charge you for any of our paid Services; * To further develop and improve our Services. For example by adding new features that we think our users will enjoy or will help them to create and manage their monitors more efficiently; * To monitor and analyze trends and better understand how users interact with our Services, which helps us improve our Services and make them easier to use; * To monitor and prevent any problems with our Services, protect the security of our Services, detect and prevent fraudulent transactions and other illegal activities, fight spam, and protect the rights and property of Cesbo and others, which may result in us declining a transaction or the use of our Services; * To communicate with you, for example through an email, about offers and promotions offered by Cesbo and others we think will be of interest to you, solicit your feedback, or keep you up to date on Cesbo and our products. ## Legal Bases for Collecting and Using Information [Section titled “Legal Bases for Collecting and Using Information”](#legal-bases-for-collecting-and-using-information) A note here for those in the European Union about our legal grounds for processing information about you under EU data protection laws, which is that our use of your information is based on the grounds that: * The use is necessary in order to fulfill our commitments to you under our Terms of Service or other agreements with you or is necessary to administer your account-for example, in order to enable access to our website on your device or charge you for a paid plan; or * The use is necessary for compliance with a legal obligation; or * The use is necessary in order to protect your vital interests or those of another person; or * We have a legitimate interest in using your information-for example, to provide and update our Services, to improve our Services so that we can offer you an even better user experience, to safeguard our Services, to communicate with you, to measure, gauge, and improve the effectiveness of our advertising, and better understand user retention and attrition, to monitor and prevent any problems with our Services, and to personalize your experience; or * You have given us your consent. For example before we place certain cookies on your device and access and analyze them later. ## Sharing Information [Section titled “Sharing Information”](#sharing-information) We do not sell our users private personal information. We share information about you in the limited circumstances spelled out below and with appropriate safeguards on your privacy: * **Subsidiaries, Employees, and Independent Contractors**: We may disclose information about you to our subsidiaries, our employees, and individuals who are our independent contractors that need to know the information in order to help us provide our Services or to process the information on our behalf. We require our subsidiaries, employees, and independent contractors to follow this Privacy Policy for personal information that we share with them. * **Third Party Vendors**: We may share information about you with third party vendors who need to know information about you in order to provide their services to us, or to provide their services to you. This group includes vendors that help us provide our Services to you (like payment providers that process your credit and debit card information, fraud prevention services that allow us to analyze fraudulent payment transactions, SMS and email delivery services that help us stay in touch with you), those that assist us with our marketing efforts (e.g. by providing tools for identifying a specific marketing target group or improving our marketing campaigns), those that help us understand and enhance our Services (like analytics providers) who may need information about you in order to, for example, provide technical or other support services to you. We require vendors to agree to privacy commitments in order to share information with them. These vendors are listed in in the “List of data sub-processors” section below. * **Legal Requests**: We may disclose information about you in response to a subpoena, court order, or other governmental request. * **To Protect Rights, Property, and Others**: We may disclose information about you when we believe in good faith that disclosure is reasonably necessary to protect the property or rights of Cesbo, third parties, or the public at large. For example, if we have a good faith belief that there is an imminent danger of death or serious physical injury, we may disclose information related to the emergency without delay. * **Business Transfers**: In connection with any merger, sale of company assets, or acquisition of all or a portion of our business by another company, or in the unlikely event that Cesbo goes out of business or enters bankruptcy, user information would likely be one of the assets that is transferred or acquired by a third party. If any of these events were to happen, this Privacy Policy would continue to apply to your information and the party receiving your information may continue to use your information, but only consistent with this Privacy Policy. * **With Your Consent**: We may share and disclose information with your consent or at your direction. For example, we may share your information with third parties with which you authorize us to do so, such as the social media services that you connect to our site. * **Aggregated or De-Identified Information**: We may share information that has been aggregated or reasonably de-identified, so that the information could not reasonably be used to identify you. For instance, we may publish aggregate statistics about the use of our Services. ### Transferring Information [Section titled “Transferring Information”](#transferring-information) Because Cesbo’s Services are offered worldwide, the information about you that we process when you use the Services in the EU may be used, stored, and/or accessed by individuals operating outside the European Economic Area (EEA) who work for us, other members of our group of companies, or third party data processors. This is required for the purposes listed in the How and Why We Use Information section above. When providing information about you to entities outside the EEA, we will take appropriate measures to ensure that the recipient protects your personal information adequately in accordance with this Privacy Policy as required by applicable law. ## Security [Section titled “Security”](#security) While no online service is 100% secure, we work very hard to protect information about you against unauthorized access, use, alteration, or destruction, and take reasonable measures to do so, such as monitoring our Services for potential vulnerabilities and attacks. ## Choices [Section titled “Choices”](#choices) You have several choices available when it comes to information about you: * **Limit the Information that You Provide**: If you have an account with us, you can choose not to provide the optional account information, profile information, and transaction and billing information. Please keep in mind that if you do not provide this information, certain features of our Services may not be accessible. * **Opt-Out of Electronic Communications**: You may opt out of receiving promotional messages from us. Just follow the instructions in those messages. If you opt out of promotional messages, we may still send you other messages, like those about your account, monitoring alerts and legal notices. * **Set Your Browser to Reject Cookies**: At this time, Cesbo does not respond to “do not track” signals across all of our Services. However, you can usually choose to set your browser to remove or reject browser cookies before using our Services, with the drawback that certain features of Services may not function properly without the aid of cookies. * **Close Your Account**: While we’d be very sad to see you go, if you no longer want to use our Services, you can close your Cesbo account. ## Your Rights [Section titled “Your Rights”](#your-rights) If you are located in certain countries, including those that fall under the scope of the European General Data Protection Regulation (AKA the “GDPR”), data protection laws give you rights with respect to your personal data, subject to any exemptions provided by the law, including the rights to: * Request access to your personal data; * Request correction or deletion of your personal data; * Object to our use and processing of your personal data; * Request that we limit our use and processing of your personal data; and * Request portability of your personal data. ## How to Reach Us [Section titled “How to Reach Us”](#how-to-reach-us) If you have a question about this Privacy Policy, or you would like to contact us about any of the rights mentioned in the Your Rights section above, please contact us by email: ## Privacy Policy Changes [Section titled “Privacy Policy Changes”](#privacy-policy-changes) We may update Our Privacy Policy from time to time. We will notify You of any changes by posting the new Privacy Policy on this page. You are advised to review this Privacy Policy periodically for any changes. Changes to this Privacy Policy are effective when they are posted on this page. # Install Astra > Step-by-step guide to install Astra binary, get a license, and set up the system service Astra installation is a simple process – just copy single binary file to your server. ## Requirements [Section titled “Requirements”](#requirements) * Any Linux-based operating system. We recommend using Fedora 42. * x86 64bit CPU * Connection to the internet on your server for periodic license validation on the servers: `ls1.cesbo.com`, `ls2.cesbo.com`, and `ls3.cesbo.com` Note This guide uses the **curl** command to download files. Most Linux distributions have **curl** pre-installed. ## Install [Section titled “Install”](#install) 1. **Open your server console and download binary file** ```sh curl -Lo /usr/bin/astra https://astra.cesbo.com/latest ``` Note This address always points to the latest version, which requires an active **Subscription**. If you have a **Lifetime** license, download a version released before your purchase date - see [Versions](./versions/). 2. **Set execute permission** ```sh chmod +x /usr/bin/astra ``` 3. **Installation completed** You can check the installed version of Astra by running: ```sh astra -v ``` ## Get License [Section titled “Get License”](#get-license) Valid license is required to launch Astra on your server. You may get demo license for free or buy subscription on our web site: To install license follow the instructions in the email with new license. ## Launch [Section titled “Launch”](#launch) After installation, register new service in the systemd: ```sh astra init ``` This command registers Astra as a system service with name `astra` and with management port `8000`. To start service launch command: ```sh systemctl start astra ``` Read more about service management and launching additional services on your server: [Manage Astra Service](./manage-service/). ## Enable autorun [Section titled “Enable autorun”](#enable-autorun) Turn autorun on for your service: ```sh systemctl enable astra ``` Now service `astra` will be started automatically on system startup. ## System Tune [Section titled “System Tune”](#system-tune) To improve performance, adjust your system settings. Use the [System Tune](./tune/) script to configure network parameters, CPU power modes, and other settings automatically. ## Login to Web Interface [Section titled “Login to Web Interface”](#login-to-web-interface) After installing Astra, you can access its web interface using a web browser - Edge, Chrome, Safari, or Firefox. The default port for the web interface is 8000. So interface address will be `http://your-server-address:8000`. To log in to the web interface, use the default login and password, which are both set to “admin”. It is recommended to change the default password to prevent unauthorized access. Read next article about [Astra Web Interface](./web-interface/) # Media Address Format In Astra, the media source or destination is described using a media address that resembles a typical URL. This format makes it easy to understand and work with the different components involved in managing media streams. ## Understanding the Media Address Format [Section titled “Understanding the Media Address Format”](#understanding-the-media-address-format) The media address format consists of three main components: type, address, and options. It follows the structure: ```plaintext type://address#options ``` * `type`: represents the protocol or method used for receiving or transmitting media streams * `address`: is a type-specific string that indicates the source or destination of the media stream. This can vary depending on the protocol being used * `options`: protocol-specific and general settings that affect the behavior of the media stream. Options are separated by an ’&’ symbol Example of a complete media address: ```plaintext dvb://a001#pnr=100&cam ``` In this example: * `dvb`: is the type, indicating that the media source is a DVB Adapter * `a001`: is the DVB Adapter identifier, specifying the specific adapter to be used * `pnr=100`: option to select the program number 100 from the stream * `cam`: option to enable CAM (Conditional Access Module) for decrypting the stream Let’s take a closer look at each of these components and their respective roles in the address format. ## Receiving Media Types [Section titled “Receiving Media Types”](#receiving-media-types) * `dvb`: media source received via a DVB Tuner or Virtual adapter. [Introduction to DVB Adapter Tuning](../../adapters/) * `udp`: [UDP multicast or unicast](../../receiving/udp/) * `rtp`: [RTP multicast or unicast](../../receiving/udp/) * `http`: HTTP based protocols: [HTTP MPEG-TS](../../receiving/http/http/) or [HLS](../../receiving/http/hls/) * `srt`: [SRT protocol](../../receiving/srt/) * `rtsp`: [RTSP protocol](../../receiving/rtsp/), commonly used to receive stream from IP camera streams * `file`: MPEG-TS file on the server ## Transmitting Media Types [Section titled “Transmitting Media Types”](#transmitting-media-types) * `udp`: [UDP multicast or unicast](../../delivery/udp/) * `rtp`: RTP multicast or unicast * `srt`: SRT protocol * `http`: HTTP based protocols, by the default HTTP MPEG-TS, or HLS if media address ends with `.m3u8` extension * `resi`: [DVB-C modulator by DigitalDevices](../../delivery/broadcast/resi-dvb-c-modulator/) * `tbs`: [DVB-C modulator by TBS](../../delivery/broadcast/tbs-dvb-c-modulator/) * `it950x`: [DVB-T modulator by HiDes](../../delivery/broadcast/hides-dvb-t-modulator/) * `file`: save stream to the MPEG-TS file, or directory on the server * `np`: (NetworkPush) the HTTP-based protocol, used to send streams from Astra to the remote server ## Type-Specific Addresses [Section titled “Type-Specific Addresses”](#type-specific-addresses) In the media address format, the type-specific address component determines the source or destination of the media stream based on the chosen protocol. To learn more about the address formats for each media type, please refer to the article links above. ## Introduction to General Input Options [Section titled “Introduction to General Input Options”](#introduction-to-general-input-options) General input options play a critical role in fine-tuning the receiving and processing of media streams. These options allow you to modify various parameters that affect the behavior of the media stream, such as filtering, analyzing, and modifying. Most common options: * `pnr=PNR`: the program number/SID (Service ID) retrieves the channel with the specified number from the stream. Read more in [MPEG-TS Demultiplexing](../../streams/processing/demux/) * `set_pnr=PNR`: to change PNR. The value must be between 1 and 65535 * `filter=N,...`: stream filtration, used to remove the specified PID. Identifiers are separated by commas. Read more in [Filtering Stream PIDs](../../streams/processing/filter/) * `filter~=N,...`: stream filtering, used to remove all data except specified PID and service tables. Identifiers are separated by commas * `order`: sort PID in the PMT table. Often used with the lang parameter to select a priority audio track. Read more in [Reorder audio streams](../../streams/processing/order/) * `lang`: set the language code for the audio track. Example: `lang.1241=eng` where: `1241` - pid, `eng` - language code Other options: * `set_tsid=TSID`: to change TSID (Transport Stream ID) * `biss=1122330044556600`: use BISS key for decrypting stream. Read more: [Decrypt streams with BISS CAS](../../streams/processing/decrypt-biss/) * `cam`: use DVB-CI for decrypting stream * `cam=CAM-ID`: use CAM Client for decrypting stream * `ecm_pid=PID`: define ECM PID for CAM Client (not recommended) * `cas`: skip service data about conditional access systems. Used to transmit an encrypted stream * `map.SRC=DST`: change PID to the specified values. SRC - the original identifier or data type. Possible types: pmt, video, audio, ait, language code. DST - required identifier. The value can be between 32 and 8190. Read more in [Remapping Stream PIDs](../../streams/processing/remap/) * `no_sdt`: to delete channel information: channel name, operator name (SDT Service Description Table) * `pass_sdt`: SDT transfer without processing. By default, if pnr is set, Astra transmits information only on the selected stream * `no_eit`: delete EPG event information (EIT - Event Information Table) * `pass_eit`: EIT transmission without processing. By default, if pnr is set, Astra transmits information only on the selected stream * `no_analyze`: disables checking for changes in the stream * `cc_limit=N`: set CC error limit. If the number of CC errors exceeds the set limit, Astra will switch to the backup source (if available). Default: no limit is set * `bitrate_limit=RATE`: set the minimum bitrate for the analyzer in Kbit/s. The source will be considered non-working if the stream bitrate is less than the specified value. Default: `16 Kbit/s` for stream without video data and `128 Kbit/s` for stream with video data * `pass_data`: retain packets with the private data (data-pid). Read more in [MPEG-TS Demultiplexing](../../streams/processing/demux/) # Backup > Create and restore backups of Astra binary and configuration files Backups are an important part of system administration! ## Create [Section titled “Create”](#create) Save binary file and configuration files to archive: ```sh tar -Pzcf ~/astra-backup.tar.gz /usr/bin/astra /etc/astra ``` ## Restore [Section titled “Restore”](#restore) To extract backup launch next commands: ```sh rm -f /usr/bin/astra tar -Pxf ~/astra-backup.tar.gz ``` ## Register the service on a new server [Section titled “Register the service on a new server”](#register-the-service-on-a-new-server) After restoring the backup on a new server, register Astra in systemd: ```sh astra init ``` This command registers Astra as a system service named `astra` with management port `8000`. To start the service, run: ```sh systemctl start astra ``` Read more about service management and launching additional services on your server: [Manage Astra Service](../manage-service/). # License > Get demo, subscription, or lifetime licenses for Astra with installation, renewal, and troubleshooting instructions You need a valid license to run Astra. If this is your first time using Astra, get a free 40-day demo license to try all features. **→ [Get your free demo license](https://app.cesbo.com/orders/software/astra/demo/)** ## License Types [Section titled “License Types”](#license-types) Astra has three licensing options: * **Demo**: a free license to try all features for 40 days. For evaluation only, not commercial use * **Subscription**: a paid license with monthly or yearly billing. Includes technical support and regular updates. You can cancel your subscription at any time * **Lifetime**: a paid license with one-time payment for permanent use. No updates - works with [versions](../versions/) released before your purchase date. You can upgrade anytime to get the latest version Each license includes a server limit. You can run Astra on as many servers as your license allows. For example, a 5-server license lets you install and use Astra on up to 5 different servers. There is no limit on the number of Astra processes you can run on a single server. ## What Happens After Getting a License [Section titled “What Happens After Getting a License”](#what-happens-after-getting-a-license) 1. **Check your email**: You’ll receive an email with your license file and installation instructions 2. **Install the license**: Follow the step-by-step instructions in the email to install your license file on your server 3. **Restart Astra**: Run `systemctl restart astra` to activate your new license 4. **Start using Astra**: Your license is now active and you can begin configuring your streaming setup Note License emails are sent immediately. If you don’t see the email, check your spam folder. ## Purchase License [Section titled “Purchase License”](#purchase-license) Ready to buy a subscription or lifetime license? Visit our website to see pricing and purchase options. **→ [Purchase License](https://cesbo.com/astra-license)** After purchase, you’ll receive your license by email with installation instructions. ## Renew License [Section titled “Renew License”](#renew-license) We’ll send you renewal reminders by email: * 7 days before your license expires * On the day your license expires Both emails include a direct link to renew your subscription. You can also renew anytime in your [Profile](https://cesbo.com/profile). Your serial number stays the same after renewal, so no additional setup is needed. After renewing, restart Astra to apply the updated license information. ## Upgrade License [Section titled “Upgrade License”](#upgrade-license) Need to add more servers to your subscription? You can upgrade anytime in your [Profile](https://cesbo.com/profile). **How pricing works**: * Upgrade cost is calculated based on your remaining subscription days * You get a discount for additional servers * Use our pricing calculator to see exact costs before upgrading **To downgrade your license**: Contact our support team for assistance. ## Transfer License [Section titled “Transfer License”](#transfer-license) You may transfer your license and subscription to another account, please contact us in chat. ## Reset License [Section titled “Reset License”](#reset-license) If you lost your license or it has been leaked, you may reset your serial number. Open your profile on our website: [Profile](https://cesbo.com/profile) and click “Reset serial number”. You will receive a new license and installation guide by email immediately. ## Move License to New Server [Section titled “Move License to New Server”](#move-license-to-new-server) You have three options to move your Astra license to a new server: ### Restore from Backup [Section titled “Restore from Backup”](#restore-from-backup) Create a backup on your old server and restore it on the new one. This moves your license and all settings. See [Backup and Restore](../backup/) guide. ### Copy License File [Section titled “Copy License File”](#copy-license-file) Copy file with your license from your old server to the new server: ```bash ssh old-server "cat /etc/astra/license.txt" | ssh new-server "sudo tee /etc/astra/license.txt" ``` ### Reset Serial Number [Section titled “Reset Serial Number”](#reset-serial-number) If you can’t access your old server, reset your serial number in your [Profile](https://cesbo.com/profile) and install the new license file you receive by email ## FAQ [Section titled “FAQ”](#faq) ### When is my payment confirmed? [Section titled “When is my payment confirmed?”](#when-is-my-payment-confirmed) Card and PayPal payments are processed almost instantly. Bank transfers are confirmed when funds arrive in our account - you can speed this up by sending the payment confirmation to our support team. After payment, you’ll receive a confirmation email and your profile will be updated with the new license information. ### When I renew my subscription, do I need to reinstall the license? [Section titled “When I renew my subscription, do I need to reinstall the license?”](#when-i-renew-my-subscription-do-i-need-to-reinstall-the-license) No, you don’t need to reinstall the license after renewal. Your serial number remains the same, so Astra will continue to use the existing license file. However, you do need to restart Astra to apply the updated license information if you’re using a version released before November 2025. You can do this via the web interface **Settings** → **Restart**. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) * [Failed to Check License](../../troubleshooting/license/failed-to-check-license/) * [Subscription Expired](../../troubleshooting/license/expired/) # Manage Astra Service > Learn how to control Astra services on your server: start, stop, restart, check logs, and run multiple instances for better performance and stability. Learn how to control Astra services on your server: start, stop, restart, check logs, and run multiple instances for better performance and stability. Tip Most Linux distributions use `systemd` to manage services. It controls whether services run, restart automatically on system startup, and provides access to service logs. ## Launch additional services [Section titled “Launch additional services”](#launch-additional-services) When you first launch Astra service with `astra init` command, default service name is `astra` and web interface port is `8000`. You can launch multiple Astra services on your server. Each service runs as a separate process with its own configuration and port. Common reasons to use multiple services: * **Load distribution**: Split channels across separate processes to balance resource usage * **Improved stability**: Isolate problematic channels that might affect other channels if they run in the same process To create an additional service: ```sh astra init 8002 astra2 ``` Service name will be `astra2` with the web interface port `8002`. ## Service management [Section titled “Service management”](#service-management) In this example service name is default: `astra2` | Command | Description | | -------------------------- | -------------------------------- | | `systemctl restart astra2` | Restart service | | `systemctl start astra2` | Start service | | `systemctl stop astra2` | Stop service | | `systemctl status astra2` | Service status | | `systemctl enable astra2` | Launch service on system startup | | `systemctl disable astra2` | Disable autorun | | `journalctl -fu astra2` | Service logs | ## Remove service [Section titled “Remove service”](#remove-service) Before removing service, stop it and turn off autorun: ```sh systemctl stop astra2 systemctl disable astra2 ``` Then, remove service from systemd: ```sh astra remove astra2 ``` This command remove service and log files, while keeping configuration and binary files. # Hardware Requirements > CPU, RAM, networking, and DVB adapter requirements for optimal Astra performance Digital TV is a high-load service and requires some resources. Astra has no restrictions on the number of channels or clients. However, the chosen protocols and available resources may influence these parameters. ## CPU [Section titled “CPU”](#cpu) We recommend a CPU with the highest available frequency. The optimal CPU frequency for a digital TV headend is 2.5 - 3GHz or higher. Processors with many cores, but lower frequency (e.g. 1.8-2.5 GHz) are not well suitable for tasks requiring low latency. Processors with L2 cache only may not be so bad, but in 99% it indicates that the rest of the equipment such as motherboard and RAM is deprecated and not suitable for use. An example of a good processor: * Intel Xeon 10C E5-2680v2 * Xeon 8C E5-2670 * Intel Xeon 6C X5670 * Core i5-9600K Ensure the CPU is operating in performance mode and power-saving mode is disabled. [Read more](../../troubleshooting/system/cpupower/). ## RAM [Section titled “RAM”](#ram) For system and general software operation we recommend at least 2Gb of RAM. Reserve at least 20%. Additional RAM is needed: * For receiving, resources are not as important as delivery. About 1Gb of RAM per 100 channels. * For DVB modulators such as TBS, DigitalDevices, or HiDes, Astra allocates 256Mb per transponder * For delivery UDP channels with bitrate synchronization, Astra allocates about 12Mb per channel. Approximately 2Gb of RAM is enough for deliver 100 channels with UDP protocol. * For delivery UDP channels without synchronization, Astra allocates only 1Mb per channel. This is generally not recommended. * For HLS delivery, RAM usage depends on the HLS settings. By default, Astra prepares 4 segments, each up to 3 seconds long. For HD channel with a bitrate of 10Mbit per second, approximately 15Mb (calculated 4 \* 3 \* 10 / 8) will be allocated, in addition to a fixed 2Mb per channel, that doesn’t depend of the channel bitrate. Each active session requires about 2Mb of RAM. The frequency of RAM is also quite an important thing. Approximate figures for comparison: * DDR1 400 MHz - not suitable * DDR2 600 MHz - suitable for small configurations, like receiving 10-15 channels and broadcasting them in udp * DDR3 1333-1600 MHz - suitable * DDR4 2133-2800 MHz - suitable * DDR4 2800-3400 Mhz - expensive and unnecessary ## Networking [Section titled “Networking”](#networking) Avoid using VLAN, Bonding and consumer-grade network adapters. ### Rx/Tx buffer size [Section titled “Rx/Tx buffer size”](#rxtx-buffer-size) NIC ring buffer sizes differ according to the NIC vendor and grade. A larger buffer size reduces the chance of packet loss during scheduling delays. * less than 1024 are generally not recommended * between 2048 and 4096 are considered good * 8192 is deemed excellent ### Queues [Section titled “Queues”](#queues) Packets are transmitted between the NIC ring buffer and the operating system kernel via queues. Each queue is assigned one dedicated CPU core. Network adapters equipped with multiple queues can process packets simultaneously. Network adapters with single queue are for consumer use only and not recommended for digital TV headend setup. ### Recommended Network Adapters [Section titled “Recommended Network Adapters”](#recommended-network-adapters) * **Intel** * 82599ES, 82599EB (2 ports) * 82599EN (1 port) * i350AM2 * **Mellanox** * MT27520 * **SolarFlare** * SFN7122F ### NOT Recommended Network Adapters [Section titled “NOT Recommended Network Adapters”](#not-recommended-network-adapters) * **D-Link**, **Realtek**: any models for consumer use only are not suitable for digital TV headend. * **Intel**: Although we recommend Intel network cards, we do not recommend these models specifically. Only one queue and all data will be processed by only one CPU core: * 82541GI Gigabit Ethernet Controller (rev 05) * 82541PI Gigabit Ethernet Controller (rev 05) * 82574L Gigabit Network Connection * 82540EM Gigabit Ethernet Controller (rev 03) * 82545EM * 82579LM * 82571EB Gigabit Ethernet Controller (rev 06) * 82573L Gigabit Ethernet Controller * 82573E Gigabit Ethernet Controller (rev 03) * 82578DC Gigabit Network Connection (rev 06) * 82546EB Gigabit Ethernet Controller (rev 01) * 82546GB Gigabit Ethernet Controller (rev 03) * I219-V (rev 31) * I217 * **Broadcom** * NetXtreme BCM5701 * NetXtreme BCM5704 * NetXtreme BCM5715 * NetXtreme BCM5719 - periodically appear dropped / missed at 256 mbit/s. * NetXtreme BCM5721 * NetXtreme BCM5722 * NetXtreme II BCM5708 * NetXtreme II BCM5709 - although there are multiple queues, RSS can only start working on one of them, creating a high load on a single running kernel * NetXtreme II BCM5716 , supports allocation of interrupts to available cores, but still leaves the bulk of packets on the core 0 * **Qualcomm** * Atheros AR8121/AR8113/AR8114 Gigabit or Fast Ethernet * Atheros AR8131 Gigabit Ethernet * Atheros AR8132 Fast Ethernet * Atheros AR8151 v2.0 Gigabit Ethernet (rev c0) * **Others** * **VMware VMXNET3** - not suitable for UDP delivery, too many dropped packets * VIA Technologies, Inc. VT6105/VT6106S \[Rhine-III] (rev 86) * 3Com Corporation 3c905C-TX/TX-M \[Tornado] * RedHat Virtio network device * Marvell 88E8057 PCI-E Gigabit Ethernet Controller * Marvell 88E8050 PCI-E ASF Gigabit Ethernet Controller * QLogic Corp. cLOM8214 1/10GbE Controller (rev 54) - does not work changing the number of queues, by default 3 rx, 1 rx tx. * HP NC326i * NVidia Corporation MCP55 Ethernet (rev a3) - only one queue. As a result, even with a small amount of traffic gives a very high load on the processor core, which is engaged in processing traffic from this network card, which leads to unacceptably slow packet processing. ## DVB [Section titled “DVB”](#dvb) ### Recommended DVB Adapters [Section titled “Recommended DVB Adapters”](#recommended-dvb-adapters) * **DigitalDevices**: All DVB adapters by [Digital Devices](https://www.digital-devices.eu) work well with Astra. * DD Max SX8 - 8 tuner S/S2 receiver + multiswitch * DD Max A8i - 8 tuner DVB-C2/T2 ISDB-T receiver * **TBS**: DVB adapters by [TBS](https://www.tbsdtv.com) are one of the most popular solutions for receiving digital television. * TBS6904 - 4 tuner S/S2 receiver * TBS6909 - 8 tuner S/S2 receiver + multiswitch * TBS6205 - 4 tuner DVB-T2/T/C receiver * **DVBSky** * T980CI - 1 tuner DVB-T/T2/C receiver with CI slot. * S950CI - 1 tuner DVB-S/S2 receiver with CI slot. * T9580 - 2 tuner S2/T2/T/C receiver with independent tuners. Recommended DVB Modulators and CI interfaces: * **DigitalDevices** * DD RESI DVB-C FSM - DVB-C modulator * DD Octopus Twin CI - 2 CI interfaces for channel descrambling * **TBS** * TBS6004 DVB-C 4 QAM PCIe Card * TBS6104 DVB-T Quad Modulator Card * TBS6900 - 2 CI interfaces for channel descrambling ### NOT Recommended DVB Modulators [Section titled “NOT Recommended DVB Modulators”](#not-recommended-dvb-modulators) * **DigitalDevices** * Digital Devices RESI SDR Modulator - DVB-T/ISDB-T (not supported. unpredictable behavior) * Digital Devices RESI SDR Modulator - PAL Modulator (not supported) * **TBS** * TBS6032 16 QAM DVB-C Modulator - (unpredictable behavior) ### NOT Recommended DVB Adapters [Section titled “NOT Recommended DVB Adapters”](#not-recommended-dvb-adapters) * SkyStar 1 - old card, does not support a standard S2 * Mystique SaTiX-SX - old card, does not support a standard S2 * Any USB adapters ## Summary [Section titled “Summary”](#summary) Total RAM needed calculated as sum of the: * General software operation * Receiving * Delivery * Other software on your server * RAM Reserve ### Example with DVB-C Broadcasting [Section titled “Example with DVB-C Broadcasting”](#example-with-dvb-c-broadcasting) In summary for 100 channels: * General software operation: 2Gb * Receiving: 1Gb * Delivery with 4 transponders: 2Gb (256Mb per transponder, plus additional resources for mulpiplexing) * Other software: 0 * RAM Reserver: (2 + 1 + 2) \* 0.5 = 2.5Gb Total (rounded up): 8Gb ### HLS [Section titled “HLS”](#hls) Due to HLS nature all clients connected directly to the server. For load balancing we recommend to use caching servers. Read more in [HLS Caching Proxy with Nginx](../../delivery/http/hls-caching-proxy-with-nginx/) # System Tune Broadcasting TV is a resource-intensive task that demands maximum performance and minimal latency from your server. To meet these critical needs, system optimization is key. This script configures system parameters for better networking, faster CPU response, and improved stability, allowing Astra to work more efficiently. ## Install script [Section titled “Install script”](#install-script) Download script for tuning your Linux settings: ```bash curl -Lo /opt/tune.sh https://cdn.cesbo.com/astra/scripts/tune.sh chmod +x /opt/tune.sh ``` Register script as a system service: ```bash /opt/tune.sh install ``` Reboot your server to apply changes. ## Uninstall script [Section titled “Uninstall script”](#uninstall-script) Remove script from your system: ```bash /opt/tune.sh uninstall ``` Delete script file: ```bash rm -f /opt/tune.sh ``` # Update Astra > Download and install the latest version of Astra with proper backup procedures Install new version on your server Danger Before update please [Make a Backup](../backup/)! ## Install update [Section titled “Install update”](#install-update) Download latest binary file: ```sh rm -f /usr/bin/astra curl -Lo /usr/bin/astra https://astra.cesbo.com/latest chmod +x /usr/bin/astra ``` Note This address always points to the latest version, which requires an active **Subscription**. If you have a **Lifetime** license, use a version released before your purchase date - see [Versions](../versions/). Restart Astra after update: ```sh systemctl restart astra ``` # Versions > All Astra versions with release dates and download links The latest version is always available at: Note The latest version requires an active **Subscription**. If you have a **Lifetime** license, use the latest version released before your purchase date. Read more about [License Types](../license/). ## All Versions [Section titled “All Versions”](#all-versions) | Version | Release date | Download | | ------- | ------------ | --------------------------------------------------------------- | | 250612 | 2025-06-12 | [astra-250612](https://cdn.cesbo.com/astra/builds/astra-250612) | | 250221 | 2025-02-21 | [astra-250221](https://cdn.cesbo.com/astra/builds/astra-250221) | | 241024 | 2024-10-24 | [astra-241024](https://cdn.cesbo.com/astra/builds/astra-241024) | | 240403 | 2024-04-03 | [astra-240403](https://cdn.cesbo.com/astra/builds/astra-240403) | | 230719 | 2023-07-19 | [astra-230719](https://cdn.cesbo.com/astra/builds/astra-230719) | | 230307 | 2023-03-07 | [astra-230307](https://cdn.cesbo.com/astra/builds/astra-230307) | | 220504 | 2022-05-04 | [astra-220504](https://cdn.cesbo.com/astra/builds/astra-220504) | ## Install a Specific Version [Section titled “Install a Specific Version”](#install-a-specific-version) Download the binary file to your server and set execute permission. For example, for version 240403: ```sh curl -Lo /usr/bin/astra https://cdn.cesbo.com/astra/builds/astra-240403 chmod +x /usr/bin/astra ``` Restart Astra after changing the version: ```sh systemctl restart astra ``` # Web Interface > Access and navigate Astra Web Interface to manage streams, adapters, and system settings Astra provides a web interface that you can use to manage and configure the software. ## Accessing the Web Interface [Section titled “Accessing the Web Interface”](#accessing-the-web-interface) Web Interface works well in these browsers: Firefox, Chrome, or Safari. The default port for the web interface is 8000. To access the web interface, enter the following URL in your web browser: `http://your-server-address:8000`, where your-server is the IP address or hostname of the server where Astra is installed. ## Login to Web Interface [Section titled “Login to Web Interface”](#login-to-web-interface)  Default login and password: `admin`. We recommend changing the default password to a more secure one to prevent unauthorized access. ## Interface Overview [Section titled “Interface Overview”](#interface-overview)  1. **Dashboard**: the dashboard presents real-time status updates for all Streams and DVB Adapters. By clicking on a card, you will open the object options. 2. **Main Menu**: is a central hub of the Astra interface. It provides users with easy navigation between different functions 3. **Sessions**: provides a list of all active sessions for HTTP/HLS clients 4. **Settings**: list of all Astra settings, such as Users management, HTTP Authentication, Astra General settings, etc. Learn more in [Astra Settings](../../settings/) 5. **Log**: real-time messages about the status of the Astra software. Learn more in [Astra Logs](../../logs/) 6. **Search**: quick search for streams and adapters. The Search function can be accessed by pressing the `S` key 7. **New Adapter**: configure a new DVB Adapter to receive signals from DVB networks, including satellite, cable, or terrestrial sources. Learn more about DVB tuning and configuration in the [Receiving DVB](../../adapters/) guides 8. **New Stream**: add a new Stream to receive channels from HTTP, UDP, RTSP, and DVB sources. Learn more about creating new stream and stream options in the Admin Guide [Astra Stream Settings](../../streams/) 9. **View**: customize interface theme and dashboard settings such a streams and dvb adapters grouping, ordering, filtering # Receiving via DVB DVB (Digital Video Broadcasting) is a suite of internationally accepted open standards for digital television. It encompasses various transmission methods, including satellite (DVB-S/S2), cable (DVB-C/C2), and terrestrial (DVB-T/T2, ISDB-T, ATSC) broadcasting. ## Media Address Format [Section titled “Media Address Format”](#media-address-format) DVB address is used to select the DVB Adapter and configure parameters for receiving the digital TV stream. The most common format of the DVB address is: ```plaintext dvb://adapter#options ``` * `adapter`: unique adapter identifier. You may find it in the DVB Adapter settings. Read more about [DVB Adapters](../../adapters/) Additional Options: * `pnr=number`: program number for MPTS streams. When defined, it enables stream demultiplexing and selects the program with the specified number * `cam`: enables descrambling using the DVB CAM module installed in the adapter Examples of DVB addresses: ```plaintext dvb://a001#pnr=100 dvb://a002#pnr=200&cam ``` ## Adapter Configuration [Section titled “Adapter Configuration”](#adapter-configuration) Please read the [DVB Adapter](../../adapters/) guide for detailed instructions on setting up and configuring your DVB adapters. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) Find more information in [Troubleshooting DVB Adapters](../../troubleshooting/dvb/) # Extended Address Format Extended address format could be used in console with MPEG-TS Analyzer. It allows to specify detailed parameters for tuning DVB transponders. ## Extended Address Format [Section titled “Extended Address Format”](#extended-address-format) ```plaintext dvb://#options ``` General options: * `adapter=0`: number of the DVB adapter (starting from 0) * `device=0`: number of the device in the adapter (starting from 0) ### DVB-S/S2 Options [Section titled “DVB-S/S2 Options”](#dvb-ss2-options) * `type=s`: adapter type: `s`, `s2` * `tp=frequency:polarization:symbolrate`: transponder parameters * `frequency`: transponder frequency in MHz * `polarization`: `h` for horizontal, `v` for vertical, `l` for left circular, `r` for right circular * `symbolrate`: symbol rate in kS/s Optional parameters: * `modulation`: modulation type: `qpsk`, `8psk`, `16apsk`, `32apsk` * `lof1`: first local oscillator frequency in MHz * `lof2`: second local oscillator frequency in MHz * `slof`: switch frequency in MHz between first and second local oscillator * `tone`: (optional flag) 22kHz tone signal * `lnb_sharing`: (optional flag) enables LNB sharing between multiple adapters. Disables LNB voltage control * `diseqc`: DiSEqC command or input number to control external switches * `diseqc_mode`: DiSEqC mode: `1.0`, `1.1`, `toneburst`, `cmd`. Default is `1.0` * `uni_scr`: unicable slot number * `uni_mode`: unicable version: `1` or `2` * `uni_frequency`: unicable user band frequency in kHz * `uni_pos`: unicable position number: `a`, `b`, `c`, or `d` * `uni_pin`: unicable user band PIN code * `rolloff`: roll-off factor: `35`, `25`, or `20` * `stream_id`: multistream transmissions ### DVB-T/T2/ISDB-T/ATSC Options [Section titled “DVB-T/T2/ISDB-T/ATSC Options”](#dvb-tt2isdb-tatsc-options) * `type=t`: adapter type: `t`, `t2`, `isdbt`, `atsc` * `frequency`: transponder frequency in MHz or Hz Optional parameters: * `bandwidth`: channel bandwidth: `8mhz`, `7mhz`, or `6mhz`. Some adapters require this parameter to be set explicitly, try `bandwidth=8mhz` if you have issues with automatic detection * `guardinterval`: guard interval: `1/32`, `1/16`, `1/8`, `1/4`, `1/128`, `19/128`, `19/256`, `pn420`, `pn595`, `pn945` * `transmitmode`: transmission mode: `2k`, `8k`, `4k`, `1k`, `16k`, `32k` * `hierarchy`: hierarchy mode: `none`, `1`, `2`, `4` * `stream_id`: multistream transmissions ### DVB-C Options [Section titled “DVB-C Options”](#dvb-c-options) * `type=c`: for DVB-C transponders * `frequency`: transponder frequency in MHz or Hz * `symbolrate`: symbol rate in kS/s Optional parameters: * `modulation`: modulation type: `qam16`, `qam32`, `qam64`, `qam128`, `qam256`, `qam512`, `qam1024`, `qam2048`, `qam4096` ## Launching femon tool [Section titled “Launching femon tool”](#launching-femon-tool) To launch the femon tool with the specified extended address format, use the following command: ```plaintext astra --femon 'dvb://#adapter=0&type=s2&tp=11044:V:43200' ``` Quotes are required around the address to prevent shell interpretation of special characters. # SAT>IP Client SAT>IP (or Sat-IP) specifies an IP-based client–server communication protocol for a TV gateway. SAT>IP server connects to one or more DVB broadcast sources and provides access to channels for multiple clients over HTTP or RTSP protocols. In this chain, Astra acts as an SAT>IP client. It can receive DVB streams over SAT>IP protocol and be used as a hub for TV Channels from different sources, for their further processing and streaming to clients. ## Benefits of using SAT>IP receivers [Section titled “Benefits of using SAT>IP receivers”](#benefits-of-using-satip-receivers) The most important advantage is the possibility of separating the reception and processing of channels. Usually Sat-dishes and terrestrial antennas are located on the roof which requires dedicated cabling to distribute the satellite signal to DVB Server (Linux PC with Astra software) which is located in the server room. This can be costly, especially in large buildings or complexes. And with the SAT>IP solutions, on the other hand, we may use existing network infrastructure to distribute the signal (or reduce cabling to a single Ethernet cable) and this can significantly reduce installation costs. Since Astra can handle large amounts of traffic without performance degradation, it is worth an option to use.  Secondly, we can extend the variety of hardware with what you may receive a DVB signal. It is SAT>IP server hardware like: [Digital Devices Octopus NET](https://www.digital-devices.eu/shop/en/Network-TV/All-Network-Tuners/), HDHomeRun, Telestar R1, and many other devices, including low-cost options, which support SAT>IP Standard. What is important to mention, is that with the Minisatip server software, we also may use PCIe DVB cards and/or USB sticks (tuners) as SAT>IP Adapters at Astra Cesbo. For more details on how to use the Minisatip server look at [our article](https://help.cesbo.com/misc/tools-and-utilities/dvb/minisatip) and on developer [GitHub](https://github.com/catalinii/minisatip). ## Configuration [Section titled “Configuration”](#configuration) To use the SAT>IP protocol, you need to create New Adapter in the Astra Web Interface:  * **Name**: write a required name for Adapter. It is better to use names that describe what equipment and what frequency is used * **Virtual**: select the “SAT>IP” option * **SAT>IP Server**: enter SAT>IP server address * **Adapter**: adapter number on the SAT>IP server * **Type**: select adapter type (Satellite/Terrestrial/Cable) Depending on the reception type, you will need additionally configure the Transponder data or Frequency to scan. You can find more detailed information at the following links: [Introduction to DVB Adapter Tuning](../../../adapters/) and [DVB-S/S2 Tuner Options](../../../adapters/s/) Save adapter settings by clicking “Apply” button. Now you can click on the “Scan” button and select the required programs.  # Receiving T2-MI > How to receive and unpack T2-MI streams in Astra with a virtual MPTS adapter T2-MI (DVB-T2 Modulator Interface) is a way to carry a whole DVB-T2 multiplex inside an MPEG-TS stream. Broadcasters use it to deliver terrestrial multiplexes to DVB-T2 transmitters, usually over satellite. In a T2-MI stream the TV channels are not regular programs. The whole DVB-T2 multiplex is packed into a single PID as data, so a normal scan does not find any channels. Astra unpacks T2-MI and gives you the channels inside. Reception works in two steps: 1. Receive the stream that carries T2-MI: from a DVB adapter or from a UDP source 2. Create a virtual MPTS adapter that unpacks T2-MI and provides the channels ## Configure the DVB adapter [Section titled “Configure the DVB adapter”](#configure-the-dvb-adapter) Skip this step if the T2-MI stream comes to your server over UDP, for example from a satellite receiver. Click “New Adapter” in the main menu and configure the adapter as usual: type, frequency, polarization, symbol rate, and other parameters. Read more: [DVB Adapters](../../../adapters/). Two settings are important for T2-MI: * **Budget Mode**: turn it on in the Advanced options. Budget mode disables hardware PID filtering, so Astra receives the whole transponder from the adapter, including the PID with T2-MI data * **ID**: you need this identifier in the next step. Set your own ID, or copy the generated one after you save the adapter Click Apply to save the adapter. In this setup the DVB adapter only delivers the transponder. The channels from the T2-MI stream are added later, from the virtual adapter. ## Find the T2-MI PID [Section titled “Find the T2-MI PID”](#find-the-t2-mi-pid) In most networks T2-MI data is carried in PID 4096. To check which PID your transponder uses, open the DVB adapter settings and press Scan. You can also check the source in the console with the [MPEG-TS Analyzer](../../../tools/mpeg-ts-analyzer/). For a UDP source: ```sh astra --analyze udp://239.255.1.1:1234 ``` For a DVB transponder, turn the adapter off in Astra first, because two processes cannot use the same tuner: ```sh astra --analyze 'dvb://#adapter=0&type=s2&tp=11044:V:43200' ``` Read more about the DVB parameters: [Extended Address Format](../extended-address/). ## Create the virtual adapter [Section titled “Create the virtual adapter”](#create-the-virtual-adapter) Click “New Adapter” in the main menu again and set the following options: * **Name**: any name that helps you find the adapter later * **Virtual**: select the **MPTS** option * **Address**: address of the T2-MI source with the T2-MI options For a DVB adapter from the previous step: ```plaintext dvb://a001#t2mi=0&t2mi_pid=4096 ``` For a T2-MI stream that comes over UDP: ```plaintext udp://239.255.1.1:1234#t2mi=0&t2mi_pid=4096 ``` Replace: * `a001` with the ID of your DVB adapter, or `239.255.1.1:1234` with the address and port of your UDP stream * `t2mi=0` with the number of the T2-MI stream you need, if it is not 0 * `t2mi_pid=4096` with the PID that carries T2-MI data, if it is not 4096 Click Apply to save the adapter, then press Scan. Astra unpacks the T2-MI stream and shows the list of channels. Select the channels you need and press Apply to add them. ## T2-MI options [Section titled “T2-MI options”](#t2-mi-options) * `t2mi=number`: number of the T2-MI stream to unpack. One PID can carry several T2-MI streams. They are numbered from 0 * `t2mi_pid=number`: PID that carries T2-MI data. Usually 4096 Set both options in the same address. ## If the scan finds no channels [Section titled “If the scan finds no channels”](#if-the-scan-finds-no-channels) * Check the signal quality on the DVB adapter * Check that **Budget Mode** is on in the DVB adapter settings * Check that the adapter ID in the address is the same as the ID of the DVB adapter * Check the T2-MI PID and the T2-MI stream number More information: [Troubleshooting DVB Adapters](../../../troubleshooting/dvb/) # Receiving HLS / HTTP MPEG-TS Astra receives streams from HTTP sources in two formats: HTTP MPEG-TS and HLS (HTTP Live Streaming). Both use standard HTTP protocol, making them compatible with existing web infrastructure, CDNs, and firewalls. ## Media Address Format [Section titled “Media Address Format”](#media-address-format) ```plaintext http://address http://address:port/path http://login:password@address:port/path#options ``` This is common HTTP address. Astra supports https as well. * `login:password` – login and password for HTTP authentication. Supports Basic and Digest authentication methods * `address` – server IP address or domain name * `port` – port number. Default: `80` for http and `443` for https * `path` – the path to the resource. Default: `/` Options: * `ua=Name` – custom User-Agent header * `timeout=N` - timeout for HLS segments loading. By default, timeout depend of the segment duration * `debug` - log response headers. Also should be turned on debug in the log messages HLS Specific Options: * `bandwidth=N` - select stream with defined bandwidth. By default, astra select stream with maximal bandwidth value HTTP MPEG-TS Specific Options: * `buffer_time=N` - specifies the size of the temporary buffer for receiving stream and synchronizing the bitrate. Astra downloads stream data to the buffer at maximum speed, then sends data evenly for processing * `no_sync` - is a short option for `buffer_time=0` turns synchronization off and downloads stream data without any limits ## Web Interface [Section titled “Web Interface”](#web-interface) To set up HTTP input in Astra, just write your source address to the Input field. ## Read more [Section titled “Read more”](#read-more) * [HTTP MPEG-TS](./http/) * [HLS Protocol](./hls/) # HLS Protocol HLS delivers video in small segments (typically 2-10 seconds each). The receiver downloads these segments one by one and assembles them into continuous playback.  ## When to use [Section titled “When to use”](#when-to-use) * Receiving from CDNs or cloud streaming services * Networks with varying quality or bandwidth * Large-scale deployments with many viewers ## Advantages [Section titled “Advantages”](#advantages) * Handles network issues better - if one segment fails, only a few seconds are affected * Supports adaptive bitrate - automatically adjusts quality based on network conditions * Works efficiently with CDNs for better distribution * Standard format supported by most streaming platforms ## Limitations [Section titled “Limitations”](#limitations) * Higher latency (typically 10-30 seconds) due to segment buffering * More complex setup with playlist files * Requires more resources for segment handling For a detailed description of HLS, refer to [RFC8216](https://www.rfc-editor.org/rfc/rfc8216){target=“\_blank”}. # HTTP MPEG-TS HTTP MPEG-TS works like downloading an infinite file. The server sends a continuous stream of data, and Astra processes it in real-time. ### When to use [Section titled “When to use”](#when-to-use) * Receiving from simple streaming servers that output a single continuous stream * Working with older equipment designed for this format * Situations where you need low latency ### Advantages [Section titled “Advantages”](#advantages) * Simple setup - just one URL to connect * Works with basic HTTP servers * Lower latency compared to HLS ### Limitations [Section titled “Limitations”](#limitations) * Sensitive to network interruptions - any connection drop causes immediate playback issues * No adaptive quality switching * Less efficient over unstable networks # Creating Backup Stream from Image > Create a backup video stream from a static image using FFmpeg and serve it via UDP for Astra. A backup video stream from a static image provides a fallback when your primary source fails. The image can display a message like “Technical difficulties, please stand by” or similar service information. This approach is also useful for Emergency Alert Systems (EAS) to broadcast visual warnings. ## Create Video File from Image [Section titled “Create Video File from Image”](#create-video-file-from-image) Video encoding is a resource-intensive task. To reduce CPU usage, pre-encode the image into short video files rather than encoding in real-time. For smooth switching between primary and backup sources, the video codec must match your main stream. Create video files for each codec format you use (H.264, HEVC, etc.). ### Check Primary Stream Format [Section titled “Check Primary Stream Format”](#check-primary-stream-format) Use `ffprobe` to analyze your primary stream: ```bash ffprobe -hide_banner -v error -show_streams -show_format udp://239.255.1.1:1234 ``` Look for these important parameters in the output: * **codec\_name** — video codec: `h264`, `hevc`, or `mpeg2video` * **width** and **height** — video resolution, for example `1920` and `1080` * **r\_frame\_rate** — frame rate, for example `25/1` means 25 fps * **pix\_fmt** — pixel format, typically `yuv420p` * **profile** — codec profile, for example `high` for H.264 * **level** — codec level, for example `40` means level 4.0 For a smooth switch between primary and backup sources, your backup video must match: * Video codec * Frame rate * Resolution * Pixel format ### Create Video File [Section titled “Create Video File”](#create-video-file) Use `ffmpeg` to convert a static image into a loopable video file. Set the parameters based on your primary stream analysis: ```bash ffmpeg -loop 1 -i image.png -c:v libx264 -profile:v high -level 40 -s 1920x1080 -r 25 -pix_fmt yuv420p -t 10 /opt/ts/backup-h264.ts ``` Options explained: * `-loop 1` — loop the input image * `-i image.png` — input image file (PNG, JPEG, or other format) * `-c:v libx264` — video codec (use `libx265` for HEVC, `mpeg2video` for MPEG-2) * `-profile:v high` — codec profile (match `profile` from ffprobe) * `-level 40` — codec level (match `level` from ffprobe) * `-s 1920x1080` — resolution (match `width` and `height` from ffprobe) * `-r 25` — frame rate (match `r_frame_rate` from ffprobe) * `-pix_fmt yuv420p` — pixel format (match `pix_fmt` from ffprobe) * `-t 10` — duration in seconds * `/opt/ts/backup-h264.ts` — output file in MPEG-TS format For HEVC streams, change the encoder: ```bash ffmpeg -loop 1 -i image.png -c:v libx265 -s 1920x1080 -r 25 -pix_fmt yuv420p -t 10 /opt/ts/backup-hevc.ts ``` For MPEG-2 streams: ```bash ffmpeg -loop 1 -i image.png -c:v mpeg2video -b:v 5M -s 1920x1080 -r 25 -pix_fmt yuv420p -t 10 /opt/ts/backup-mpeg2.ts ``` ## Create Stream from Video File [Section titled “Create Stream from Video File”](#create-stream-from-video-file) Run FFmpeg to loop the video file and output it as a UDP stream: ```bash ffmpeg -stream_loop -1 -re -i /opt/ts/backup-h264.ts -c copy -f mpegts 'udp://127.0.0.1:15001?pkt_size=1316' ``` Options explained: * `-stream_loop -1` — loop the file infinitely * `-re` — read input at native frame rate * `-i /opt/ts/backup-h264.ts` — input video file * `-c copy` — copy streams without re-encoding * `-f mpegts` — output format * `pkt_size=1316` — UDP packet size for MPEG-TS ## Running FFmpeg as a Service [Section titled “Running FFmpeg as a Service”](#running-ffmpeg-as-a-service) To keep FFmpeg running continuously, set it up as a systemd service. Create file `/etc/systemd/system/backup-h264.service` with the following content: ```ini [Unit] Description=Backup Video Stream from Image After=network-online.target Wants=network-online.target [Service] Type=simple ExecStart=/usr/bin/ffmpeg \ -hide_banner -loglevel warning -nostats \ -stream_loop -1 \ -re \ -i /opt/ts/backup-h264.ts \ -c copy \ -f mpegts 'udp://127.0.0.1:15001?pkt_size=1316' Restart=always RestartSec=5 StandardOutput=null StandardError=journal [Install] WantedBy=multi-user.target ``` Replace in this file: * **File Name**: use a relevant name instead of `backup-h264.service` if you have multiple backup streams * **Description**: change to match your use case * **Input File**: replace `/opt/ts/backup-h264.ts` with the actual path to your video file * **UDP Port**: change `15001` to the UDP port you want to use. If you have multiple backup streams, use different ports. After creating the service file, enable and start the service: ```bash systemctl enable backup-h264 systemctl start backup-h264 ``` ## Configure Astra [Section titled “Configure Astra”](#configure-astra) In the channel settings, add a second input source with the UDP address: ```plaintext udp://127.0.0.1:15001 ``` Astra will automatically switch to this backup stream when the primary source fails. # Receiving Radio Streams Radio streams commonly use the ICY protocol - a streaming protocol developed for internet radio broadcasting. Many radio stations use Icecast or Shoutcast servers to deliver their content. While ICY is similar to HTTP, it has some key differences in how it handles metadata and stream information. ## How to Find Radio Stream URLs [Section titled “How to Find Radio Stream URLs”](#how-to-find-radio-stream-urls) If you only know the radio station’s website address, you can find the stream URL using your browser’s developer tools: 1. Open the radio station’s website in your browser 2. Open the Web Inspector (Developer Tools) and go to the **Network** tab 3. Start playing the radio on the website 4. In the Network tab, look for a row with type **media** where the size keeps increasing continuously 5. Right-click on that row and select **Copy** → **Copy URL**  The copied URL is the direct stream address you can use with FFmpeg. ## Receiving Radio with FFmpeg [Section titled “Receiving Radio with FFmpeg”](#receiving-radio-with-ffmpeg) Astra doesn’t support the ICY protocol directly. However, you can receive radio streams using FFmpeg to convert them into a format Astra can work with. Use FFmpeg to receive an ICY stream and output it as UDP that Astra can receive: ```bash ffmpeg -i http://radio.example.com:8000/stream -c copy -f mpegts 'udp://127.0.0.1:15001?pkt_size=1316' ``` Then configure Astra to receive from this UDP address: ```plaintext udp://127.0.0.1:15001 ``` ## Running FFmpeg as a Service [Section titled “Running FFmpeg as a Service”](#running-ffmpeg-as-a-service) To keep FFmpeg running continuously, you can set it up as a systemd service. Create file `/etc/systemd/system/radio-name.service` with the following content: ```ini [Unit] Description=Forward Radio Name to Astra After=network-online.target Wants=network-online.target [Service] Type=simple ExecStart=/usr/bin/ffmpeg \ -hide_banner -loglevel warning -nostats \ -timeout 5000000 \ -reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5 \ -re \ -i https://radio-stream:7378 \ -c:a copy \ -f mpegts 'udp://127.0.0.1:15001?pkt_size=1316' Restart=always RestartSec=5 StandardOutput=null StandardError=journal [Install] WantedBy=multi-user.target ``` Replace in this file: * **File Name**: use instead `radio-name.service` a relevant name to the radio station (if you have multiple services) * **Description**: change `Radio Name` to the name of the radio station * **Stream URL**: replace `https://radio-stream:7378` with the actual stream URL of the radio station * **UDP Port**: change `15001` to the UDP port you want to use After creating the service file, enable and start the service with: ```bash systemctl enable radio-name systemctl start radio-name ``` To stop the service, use: ```bash systemctl stop radio-name ``` To disable it from starting on boot, use: ```bash systemctl disable radio-name ``` ## Configure Astra [Section titled “Configure Astra”](#configure-astra) Finally, configure Astra to receive the UDP stream by adding a new input with the address: ```plaintext udp://127.0.0.1:15001 ``` # Receiving via RTSP RSTP is a popular protocol for streaming media over IP networks and is commonly used in IP cameras due to its low-latency and high-quality video streaming capabilities ## Address format [Section titled “Address format”](#address-format) RSTP addresses are used to identify the location of the media stream that is being transmitted over the network ```plaintext rtsp://address rtsp://address:port/path rtsp://login:password@address:port/path#options ``` * `login:password` – login and password for RTSP authentication. Supports Basic and Digest authentication methods * `address` – IPv4 server address or domain name * `port` – port number. Default: `554` * `path` – the path to the resource. Default: `/` Options: * `tcp` – interleaved mode. receive stream over TCP instead UDP * `ua=Name` – custom User-Agent header ## Web Interface [Section titled “Web Interface”](#web-interface) To set up an RSTP input in Astra, you can either enter the source address directly into the `Input address` field in the Stream settings or use the Input configuration form accessed by clicking on the gear icon form:  * `RSTP address` - source address of the RSTP stream * `Interleaved mode` - by the default Astra uses UDP to receive media data from camera, interleaved mode force camera to send data over TCP ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) ### h.265 not working [Section titled “h.265 not working”](#h265-not-working) The current version of Astra supports H.264 only ### Timeout errors [Section titled “Timeout errors”](#timeout-errors) The error messages may include `Connection timeout` or `Response timeout`, which suggest that the camera is not responding to requests from Astra. One possible cause of this issue is when the camera is stuck and cannot respond to requests ### Authentication failed [Section titled “Authentication failed”](#authentication-failed) Invalid login or password to the RTSP stream ### Unknown encoding format [Section titled “Unknown encoding format”](#unknown-encoding-format) This may indicate that the data format of the stream is not recognized by Astra. This error can occur when the RSTP stream uses an unsupported data format or encoding method # Receiving via SRT The Secure Reliable Transport (SRT) protocol is an open-source video streaming protocol designed to provide low-latency, high-quality video streaming over unreliable networks. SRT uses end-to-end encryption and provides a range of features designed to enhance reliability and security, including error correction, congestion control, and retransmission of lost packets. SRT is often used for live video streaming applications, such as sports and news broadcasts, where maintaining a reliable, high-quality connection is critical. ## Address format [Section titled “Address format”](#address-format) SRT can be received in two modes: * `Caller mode` - Astra sends a request to the SRT server and receives content in response. This is the most popular variant * `Listener mode` - Astra waits for the SRT server to establish a connection and receives content in the request. This is a point-to-point mode The address format depends on the selected mode. ### Caller mode [Section titled “Caller mode”](#caller-mode) ```plaintext srt://address:port[#options] ``` * `address` - remote server IPv4 address or hostname * `port` - remote port Example: * `srt://example.com:3001` - send request to example.com ### Listener mode [Section titled “Listener mode”](#listener-mode) In listener mode, the address format is similar to the UDP address, with the addition of the `@` symbol to indicate the local interface name. ```plaintext srt://[interface]@:port[#options] ``` * `interface` - local interface name where to listen for connection. By default, Astra waits for a connection on all interfaces * `port` - local port to accept incoming connections * `options` - additional options for SRT protocol Examples: * `srt://@:3001` - wait for connection on any interface * `srt://eth0@:3001` - wait for connection on interface `eth0` Caution Avoid using ports in the dynamic port range when configuring Listener mode. In Linux, the dynamic port range is typically 32768-60999 (you can check the range on your system with `cat /proc/sys/net/ipv4/ip_local_port_range`). Using ports in this range may cause conflicts with ports that Linux allocates dynamically for outbound connections, such as SRT Caller mode connections. ### Options [Section titled “Options”](#options) * `timeout=N` - restarts the receiver if no data is received within a defined interval, in seconds. Default: `5` seconds * `latency=N` - maximum accepted transmission latency, in milliseconds. Default: `120` milliseconds * `packetfilter=S` - injects extra processing instructions at the beginning and/or end of a transmission to implement Forward Error Correction (FEC). [Read more](https://github.com/Haivision/srt/blob/master/docs/features/packet-filtering-and-fec.md#configuring-the-fec-filter){target=“\_blank”} in the official documentation * `passphrase=S` – password for encrypted transmission. Length: 10-79 characters * `pbkeylen=N` – crypto key length in bytes. Values: 16, 24, 32. Default: `0` * `streamid=ID` – stream identifier provided to the SRT server in caller mode * `no_tsbpdmode` – turns off timestamp-based packet delivery mode * `oheadbw` - limits bandwidth overhead, in percent. Range: 5-100. Default: `25` ## Web Interface [Section titled “Web Interface”](#web-interface) To configure SRT reception, go to **New Stream** or the settings of an existing stream and set **Input Type** to **SRT**.  * **Input type**: Select **SRT** to enable SRT-specific configuration options. * **SRT mode**: Determines whether Astra acts as a **Caller** or **Listener**. Select **Listener** to wait for incoming connections. * **Local interface**: The network interface for receiving the stream. Default is **Any interface**. * **Port**: The network port for receiving the stream. * **Timeout**: Time in milliseconds to wait for incoming data before timing out. Default: 5000 ms (5 seconds). * **Latency**: Delay in milliseconds to improve stability. Default: 120ms. Higher latency increases stability but adds delay. See [Latency for SRT Receiving](./latency/) for more details. * **Passphrase**: Password for secure communication. Must match the sender’s passphrase. * **Crypto key length**: Length of the cryptographic key (16, 24, or 32 bytes). Default: 16 bytes (128 bits). * **Timestamp-based packet delivery mode**: When enabled, uses timestamps to ensure correct packet order. Default: Disabled. # Latency for SRT Receiving **Latency** is a SRT parameter that determines the maximum time the receiver waits for lost packets to be retransmitted. Higher latency improves reliability on unstable networks but increases stream delay. ## Calculating Optimal Latency [Section titled “Calculating Optimal Latency”](#calculating-optimal-latency) The recommended latency value is 4 times the Round-Trip Time (RTT) between the sender and receiver. To measure RTT, use the `ping` command: ```plaintext ping example.com ``` Example output: ```plaintext 64 bytes from example.com: icmp_seq=1 ttl=52 time=58.5 ms 64 bytes from example.com: icmp_seq=2 ttl=52 time=57.8 ms 64 bytes from example.com: icmp_seq=3 ttl=52 time=59.1 ms ``` In this example, the average RTT is approximately 58ms. The optimal rounded latency value would be: ```plaintext Latency = RTT * 4 = 58 * 4 = 240 ``` For networks with variable RTT, use the maximum observed value for calculation. For example, if RTT fluctuates between 25ms and 50ms, calculate latency based on 50 ms. ## Input configuration [Section titled “Input configuration”](#input-configuration) In Astra set the latency parameter in the SRT input options: ```plaintext srt://example.com:port#latency=240 ``` ## Insufficient Latency [Section titled “Insufficient Latency”](#insufficient-latency) If the latency value is too low, SRT cannot recover lost packets in time. The log will show errors like: ```plaintext RCV-DROPPED 1 packet(s). Packet seqno %579915997 delayed for 0.556 ms ``` This message indicates that packets were dropped because they arrived too late to be delivered. To resolve this issue, increase the latency value. # Receiving via UDP / RTP UDP (User Datagram Protocol) is the most popular protocol for delivering digital TV in local networks, including those in hospitality organizations and internet provider city networks. As a connectionless protocol, UDP does not provide any error-checking or correction mechanisms. This makes it a faster and more lightweight protocol than TCP. ## Media Address Format [Section titled “Media Address Format”](#media-address-format) UDP address is used to identify the location of the media stream that is being transmitted over the network ```plaintext udp://address udp://address:port udp://interface@address:port#options ``` * `interface`: name of the network interface, such as `eth0`, to receive UDP stream. If not defined, the UDP stream will be received according to the system routes * `address`: IPv4 address of the UDP stream, It could be a multicast group or a local interface IP address to receive unicast streams * `port`: network port to receive the UDP stream. If not specified, the default value is `1234` Additional Options: * `src=IP`: UDP multicast source address for IGMPv3. Should be enabled IGMPv3 in linux settings: [Configure IGMP Version](../../troubleshooting/udp/igmp-version/). Available from version 230303 and later * `sync`: receives UDP in separate thread with bitrate syncing * `no_sync`: disables bitrate syncing if enabled globally * `renew=seconds`: interval for renewing the multicast subscription. Usually operation renew IGMP subscription automatically * `socket_size=bytes`: size of the system socket, with the default value taken from: `sysctl net.core.rmem_default` Examples of UDP addresses: * `udp://127.0.0.1:10001`: receives the stream on localhost using port 10001. This can be useful for transferring streams between different services, like receiving a transcoded stream from FFmpeg * `udp://eth0@239.255.1.1#pnr=100`: receives multicast group 239.255.1.1 on the eth0 interface. The option `pnr` enables stream demultiplexing and selects program number 100 ## Web Interface [Section titled “Web Interface”](#web-interface) To configure a new UDP input using the Web Interface, begin by selecting “New Stream” from the main menu. Then, in the Input List, click on the gear icon and set the “Input Type” to UDP. Alternatively, you can modify an existing stream by opening its settings, adding a New Input, and clicking on the corresponding gear icon.  Most options presented in the web interface correspond directly to the components of the UDP address, as described in the “Media Address Format” section. However, there are also some additional options you might find useful: * `PNR`: program number for MPTS streams. When defined, it enables stream demultiplexing and selects the program with the specified number * `DD-CI CAM`: this option is now deprecated and has been replaced by virtual adapters. More information can be found in … * `Softcam`: selects a descrambler for the CAM Client. You can learn more about this in … * `BISS Key`: key for the BISS CAS descrambler. More details can be found in [Decrypt streams with BISS CAS](../../streams/processing/decrypt-biss/) There are also advanced options available for further customization:  Please use the advanced options only if you understand their implications ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) Find more information in [Troubleshooting UDP Input](../../troubleshooting/udp/input/) # MPTS via UDP With Astra, you can receive MPTS (Multi Program Transport Stream) from different sources, including UDP. The received MPTS can be demultiplexed into several SPTS (Single Program Transport Stream) channels. ## Virtual Adapter [Section titled “Virtual Adapter”](#virtual-adapter) Caution Virtual Adapter available for versions released after 20 Sep 2022 For quick and simple configuration of MPTS reception, you may use the Virtual Adapter. Click on “New Adapter” in the main menu:  In the **Address** field set the source UDP, for example `udp://239.255.1.1:1234`. Read more about UDP address format in [Receiving UDP/RTP](../). Apply changes, and then you can scan the adapter to get a list of available channels. Select the channels you want to add and click apply. ## Create channels manually [Section titled “Create channels manually”](#create-channels-manually) On any Astra version you may append channels from MPTS stream manually. First of all analyze UDP MPTS with MPEG-TS Analyzer: ```sh astra --analyze udp://239.255.1.1:1234 ``` Read more how to analyze streams: [Astra MPEG-TS Analyzer](../../../tools/mpeg-ts-analyzer/). Analyzer shows information about available channels, for example: ```plaintext INFO: PMT pnr:100 version:1 INFO: PMT pnr:200 version:1 ``` Next you can create channel by clicking `New Stream` in the main menu. In the channel settings set name and input address with program number (PNR): `udp://239.255.1.1:1234#pnr=100`. And click Apply to save settings. # Settings Overview  * [General](./general/) * [Users](./users/) * [HLS](../delivery/http/hls-segmenter/) * [HTTP Play](../delivery/http/http-play/) * [HTTP Authentication](../delivery/http/auth/) * [CAS](../delivery/broadcast/cas-and-simulcrypt/) * Servers * [Groups](./groups/) * Import - import channels from m3u playlist or from Astra configuration file * Edit Config - export or edit Astra configuration file * License - show license information and Astra version * Restart - restart Astra. If you have several servers with Astra, will ask which server to restart * Logout - logout from the Astra Web Interface # Custom port for Astra Web Interface Default port for Astra Web Interface is `8000`. You may set any port you want. Open **Settings** → **General** → **HTTP Server** in Astra Web Interface and set option **Custom Port** in the **Admin Interface** group. Click **Apply** button to save changes. ## Change port via console [Section titled “Change port via console”](#change-port-via-console) You can change Astra Web Interface port via server console command: ```plaintext astra init 4000 astra ``` `astra` at the end of command is a default service name. Finally restart service to apply changes: ```plaintext systemctl restart astra ``` Now web interface will be available on new port: `http://your-server:4000` # General Settings General Settings in Astra encompass a collection of essential configuration options that allow you to customize and optimize your software setup. These settings ensure a seamless streaming experience by managing aspects like InfluxDB integration, HTTP Server Settings, and Default Stream Options. ## Monitoring Options [Section titled “Monitoring Options”](#monitoring-options)  ### InfluxDB Integration [Section titled “InfluxDB Integration”](#influxdb-integration) The InfluxDB integration options in Astra allow you to configure the connection between Astra and InfluxDB for storing statistics related to streams and adapters. * **Instance Name**: data store name. As a default Astra used the InfluxDB * **InfluxDB Address**: attached storage address. As a default address of the InfluxDB is: `http://db-server:8086` * **InfluxDB Organization**: name of your orgranization in the InfluxDB settings * **InfluxDB Token**: if you need to connect an external interface, then you need to enter API token from clipboard For a detailed guide, please refer to [Integration Astra with InfluxDB](../../monitoring/influxdb/) ### Analyzer Webhook [Section titled “Analyzer Webhook”](#analyzer-webhook) The Monitoring feature in Astra is a legacy option that enables sending event data, such as stream and adapter statistics, through HTTP POST requests to external services. Read more in: [Export Monitoring Events](../../monitoring/export-monitoring-events/) ### Sessions Webhook [Section titled “Sessions Webhook”](#sessions-webhook) Exporting events on closing sessions. * **URL**: webhook URL for sending events * **Minimal Session Time**: minimum session duration in seconds for sending events. If the session lasts less than this time, no event will be sent ## HTTP Server Options [Section titled “HTTP Server Options”](#http-server-options)  The HTTP Server Options in Astra allow you to configure the HTTP Server for providing access to media content using HTTP MPEG-TS or HLS protocols. * **HTTP Access Log**: full path to the file for writing the request log * **HTTP Sessions**: enables HTTP Sessions to authenticate and track user activity. When enabled, the “Sessions” item appears in the main menu to view all active sessions. Options enabled by default * **Sessions Backend Address**: webhook to export information about sessions on finalization * **Minimal Session Time**: send webhook information about sessions lasting longer than the minimal time. To enable HTTPS, configure the following options: * **TLS certificate chain**: full path to the certificate chain. For example: `/etc/dehydrated/certs/example.com/fullchain.pem` * **TLS certificate key**: full path to the certificate key. For example - `/etc/dehydrated/certs/example.com/privkey.pem` * **Disable TLS on primary port**: check this option if you want the primary port, defined by the command-line argument `-p PORT`, to work without HTTPS You can obtain a free certificate from Let’s Encrypt. For a detailed guide, please refer to [acme.sh](https://acme.sh/) ## Default Stream Options [Section titled “Default Stream Options”](#default-stream-options)  These settings are global for all streams (unless overridden in the stream settings) * **Start stream on demand**: activate streams in the presence of HTTP clients. Enabled by default * **HTTP Keep Active**: defines time in seconds, during which the stream will be active, despite the absence of clients. By the default is 0 - turns channel off immediately when last client closed session * **Backup Start Delay**: sets delay in seconds before switching to a backup source * **Backup Return Delay**: sets delay in seconds before returning to the previous source * **Default codepage**: define codepage for stream information in SDT * **Service provider**: your company name. Used in the SDT stream description * **Network name**: name of the provider’s network. Used in the SDT stream description * **TCP Congestion Control**: defines the operation algorithm for TCP CC * **CC Limit**: sets limit on the number of CC errors in the source. After exceeding this limit - the source will be considered non-working * **Use multithreading for UDP receiving and transmitting**: launch separate threads for processing UDP sockets, turned on by the default * **Bind DVB adapters by MAC**: use DVB MAC addresses to bind configured adapters to the system device ## Default Adapter Options [Section titled “Default Adapter Options”](#default-adapter-options)  These settings are global for all adapters (unless overridden in the adapter settings) * **Bind DVB adapters by MAC**: use DVB MAC addresses to bind configured adapters to the system device Note After saving the general settings, Astra restarts # Channel Groups Channel Grouping in Astra helps you organize and manage your media content. By using categories and groups, you can make channel packages to fit each customer’s subscription plan. Also, it makes arranging channels on your dashboard easier for better management. To access and configure group settings, navigate to Settings → Groups in your Astra Web Interface. ## Categories [Section titled “Categories”](#categories) Categories in Astra serve as the top level in the channel grouping hierarchy. They are broad classifications that help you organize your content on a large scale. For example, you can use a “Genre” category to divide channels into various genres such as movies, sports, or travel.  * **Category**: select an existing category or create a new one * **Name**: category name ## Groups [Section titled “Groups”](#groups) Groups in Astra act as sub-categories within the larger categories. These are more specific classifications that help further sort your channels. Each group contains channels related to its specific theme. When you select a category in the Astra Dashboard settings, all channels within that category are automatically grouped by these Groups, for enhanced organization and easier management.  * **Add group**: add a new group to the category * **Guide Arrows**: located on the right side of each field allows to change group position or remove Group If you want to remove a category and all its related groups, simply select the `Remove category` checkbox and click “Apply” button. It’s important to remember that this action only deletes the category and groups, not the channels within them. Also note, once done, this action cannot be undone. ## Streams [Section titled “Streams”](#streams) The “Streams” button opens a list of all channels available in the Astra. In this form, you can add channels and streams to groups or remove them from groups.  # Managing Users Astra features a simple user management system with three distinct user types, designed to cater to the needs of administrators, technical support, and end-users. ## User Roles [Section titled “User Roles”](#user-roles) In Astra, there are three main user roles, each with different levels of access and functionality: * **Admin**: This role grants full access to manage and control Astra through both the Web-interface and API. Admins can view and modify all settings and configurations as needed * **Observer**: This role allows read-only access to the web-interface dashboard and API. Observers can monitor the system but cannot make changes to the settings or configurations * **User**: This regular user role is designed for controlling access to media content with built-in HTTP Authentication ## User List [Section titled “User List”](#user-list) In the Astra web interface, you can access the users list by navigating to Settings → Users  The users list is presented as a table with the following fields: * **Login**: unique username for each user * **Comment**: any additional notes or comments about the user * **Type**: role assigned to the user * **Created**: date when the user account was created When built-in HTTP authentication to control media access is turned on, additional fields will be available in the users list: * **IP**: allowed device IP address for the user, from which access to media content is permitted * **Expiration**: date until which the user account remains active ## New User [Section titled “New User”](#new-user) To create a new user, open the Users list by navigating to Settings → Users. Click the “New User” button located at the top of the list.  When creating a new user, you will need to fill in the following fields: * **Enable**: user is enabled by the default * **Login**: unique username * **Password**: optionally, set a password for the account * **Comment**: optionally, add any additional notes or comments about the user * **Type**: appropriate user type ## Built-in HTTP Authentication [Section titled “Built-in HTTP Authentication”](#built-in-http-authentication) Built-in HTTP authentication in Astra helps control access to the provided media content. You can enable this feature by navigating to Settings → HTTP Authentication in the Astra web interface. When HTTP Authentication is active, the user options include additional optional fields:  * **Token**: static secret, typically used to grant access to other servers, such as transcoders or other media streamers. The token is simply appended to the channel address, like: `http://example.com/channel-id/index.m3u8?token=secret` * **IP**: static IP address for the device that is allowed access. By default, any IP is allowed. * **Expiration**: date until which the user account remains active. By default, there is no time limit for the account. * **Limit connections**: number of simultaneous connections allowed for the user. By default, there are no connection limits. * **Packages**: click “New Package” to add a channel category to the user. The user will only have access to channels related to the specified category. New categories can be created in Settings → Groups. By default, all channels are available to the user. Read more about [Built-in Users Authentication](../../delivery/http/auth-user/) and other [HTTP Authentication options](../../delivery/http/auth/). # Streams Configuration Overview Streams in Astra represents an individual channel or media flow that receives content from various sources, processes it, and delivers it to clients. ## Create New Stream [Section titled “Create New Stream”](#create-new-stream) To create a new stream: 1. Go to the main Dashboard 2. Click “New Stream” in the upper right corner ## General Options [Section titled “General Options”](#general-options) Configure basic stream settings that control how your stream behaves and appears in the system.  * `Enable`: new stream is enabled by default, but can be turned off if needed * `Name`: friendly channel name used in dashboards and logs * `ID`: unique stream identifier. Keep it empty to assign a sequential number to new channels or you may define your own * `Create Multi Program Stream`: switch to MPTS configuration * `Description`: arbitrary channel description ### Input List [Section titled “Input List”](#input-list) Configure one or more inputs to receive stream content. To set up inputs, you can use the [Media Address Format](../quick-start/address-format/) or the configuration dialog. Read more information in our guides for protocol specific configuration: * [HLS](../receiving/http/hls/) * [HTTP MPEG-TS](../receiving/http/http/) * [UDP/RTP](../receiving/udp/) * [SRT](../receiving/srt/) * [RTSP](../receiving/rtsp/) * [How to receive MPTS via UDP](../receiving/udp/mpts-via-udp/) * [How to configure DVB, ATSC, ISDB-T, SAT>IP](../adapters/) ### Output List [Section titled “Output List”](#output-list) Configure one or more outputs to provide content to clients. Outputs are optional. You can use the [HTTP Play](../delivery/http/http-play/) feature to provide access to channels with HLS or HTTP MPEG-TS. Read more information in our guides for protocol specific configuration: * [UDP](../delivery/udp/) * DVB with Broadcasting hardware, such as: [HiDes DVB-T](../delivery/broadcast/hides-dvb-t-modulator/), [RESI DVB-C](../delivery/broadcast/resi-dvb-c-modulator/), [TBS DVB-C](../delivery/broadcast/tbs-dvb-c-modulator/) ## Single Program Stream [Section titled “Single Program Stream”](#single-program-stream) SPTS (Single Program Stream) is the default stream type for creating individual TV channels. Think of it as one channel carrying one program - like CNN or ESPN. SPTS automatically switches between multiple inputs if one fails. For example, if you have two satellite feeds for the same channel, SPTS monitors both and switches to the backup feed when problems occur. You can also process the stream by: * Filtering unwanted content (like subtitles you don’t need) * Changing stream details (channel name, language info) * Removing encryption from protected streams * Adding encryption to secure your broadcasts ## Multi Program Stream [Section titled “Multi Program Stream”](#multi-program-stream) MPTS (Multi Program Stream) combines multiple channels into one broadcast stream. Think of it like a cable TV package - instead of sending channels separately, you bundle them together for broadcasting. For example, if you have 10 different TV channels, MPTS packages them all into one stream that cable or satellite providers can broadcast to viewers. MPTS includes broadcasting features like: * Channel descriptions and network information * Channel numbering (so viewers see “Channel 5” instead of technical IDs) * Network search capabilities for receivers to find channels easily * EPG (Electronic Program Guide) data embedding for showing TV schedules to viewers Read more about [MPTS Settings](./mpts/) # General Settings MPTS (Multi Program Transport Stream) lets you bundle multiple TV channels into a single stream. This is useful when you need to send several channels together to broadcasting equipment or cable networks. For example, instead of sending Channel 1, Channel 2, and Channel 3 as separate streams, MPTS combines them into one stream that carries all three channels. ## Creating an MPTS Stream [Section titled “Creating an MPTS Stream”](#creating-an-mpts-stream) To create an MPTS stream: 1. Go to the main Dashboard 2. Click **New Stream** in the upper right corner 3. Check the **Multi Program Stream** checkbox 4. Configure the settings below ## General [Section titled “General”](#general) The General tab contains the basic settings for your MPTS stream.  ### Basic Settings [Section titled “Basic Settings”](#basic-settings) * **Enable**: Turn the MPTS stream on or off * **Name**: Give your MPTS stream a name to identify it in the interface * **ID**: Auto-generated when you save (optional field) ### Location Settings [Section titled “Location Settings”](#location-settings) * **Country**: Country code where the local time offset applies. Used for correct time adjustment in regional broadcasts. Use [ISO 3166-1 alpha-3](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3) format * **UTC Offset**: Set time zone offset from UTC (-720 to +780 minutes). This helps TVs set the correct time automatically ### Network Settings [Section titled “Network Settings”](#network-settings) * **Network ID**: Unique number for your DVB network (default: 1) * **Network Name**: Name for your DVB network * **Provider Name**: Your company or organization name (shows when users scan channels) * **Codepage**: Character encoding for text. Use Latin (ISO 6937) for English ### Stream Identifiers [Section titled “Stream Identifiers”](#stream-identifiers) * **TSID**: Transport Stream ID - unique number for this stream (default: 1) * **ONID**: Original Network ID - identifies the original network. Must be the same for all streams in your network (default: 1) ## Input List [Section titled “Input List”](#input-list) The Input List defines which streams (TV Channels) will be combined into your MPTS output. Each input represents a single channel that you want to include in the final multi-channel stream.  ### Managing Inputs [Section titled “Managing Inputs”](#managing-inputs) * **New Input**: Add a new stream to your MPTS stream * **Reorder (↑↓)**: Change the order of channels in the list * **Settings (⚙)**: Configure individual channel settings like source URL and program number ### Important Settings [Section titled “Important Settings”](#important-settings) Each input stream needs unique identifiers to avoid conflicts: * **Unique PIDs**: Each channel must have different packet identifiers. By default, Astra assigns unique PIDs automatically * **Program Numbers**: Assign unique program numbers using `set_pnr=` option **Example input URLs:** ```plaintext udp://225.1.1.27:1234#set_pnr=11 udp://225.1.1.28:1234#set_pnr=12 udp://225.1.1.29:1234#set_pnr=13 ``` This creates three channels with program numbers 11, 12, and 13 respectively. ### Use Streams from Astra [Section titled “Use Streams from Astra”](#use-streams-from-astra) You can also use existing streams from the Astra as inputs for your MPTS stream. This allows you to use channels that are already configured and prepared for MPTS. Use the `stream://` URL format and specify the stream ID you want to include. **Example input URL:** ```plaintext stream://a123 ``` So example flow will look like this: * SPTS streams used to receive channels from external sources (like UDP or DVB), prepare them for broadcasting (e.g., set program numbers, PIDs, filters, etc.) * MPTS stream combines these SPTS streams into a single multi-channel output ## Output List [Section titled “Output List”](#output-list) The Output List defines where your MPTS stream will be sent. After combining multiple channels into a single MPTS stream, you need to specify the destination(s) where this combined stream should be delivered.  ### Managing Outputs [Section titled “Managing Outputs”](#managing-outputs) * **New Output**: Add a new destination for your MPTS stream * **Settings (⚙)**: Configure output settings like destination URL, constant bitrate, and other parameters ### Common Output Types [Section titled “Common Output Types”](#common-output-types) Your MPTS stream can be sent to various destinations: * **UDP Multicast**: Send to network devices or other streaming servers * **Hardware**: Send to broadcasting equipment Read more about DVB modulator configurations: * [DigitalDevices RESI DVB-C Modulator](../../delivery/broadcast/resi-dvb-c-modulator/) * [TBS DVB-C Modulator](../../delivery/broadcast/tbs-dvb-c-modulator/) * [HiDes DVB-T Modulator](../../delivery/broadcast/hides-dvb-t-modulator/) # Advanced Settings The Advanced tab contains specialized MPTS settings. These options are typically used for troubleshooting or integration with external systems. Most users can leave these settings at their default values.  * **Disable PID’s auto-remap**: Prevents Astra from automatically reassigning PID numbers. Use when you need to preserve original PID values from source streams * **SI packets interval**: How often service information is transmitted (default: 500ms). Only change if required by specific equipment * **Pass NIT/SDT/EIT/TDT**: Skips table processing and passes original tables from source. Enable when using external EPG generators or pre-configured tables * **PAT/NIT/CAT/SDT version**: Custom version numbers for service tables. By default Astra automatically increments version when settings change to trigger updates on devices. Manual changes are rarely needed # NIT Settings The NIT (Network Information Table) tab lets you configure network information for your MPTS stream. It provides information for viewers’ devices about available networks, including network ID, name, and frequency.  * **LCN Version**: The Logical Channel Number controls how channels are ordered on viewers devices in your region * **Delivery Type**: Method used to deliver the signal (cable, terrestrial, satellite) * **Frequency**: Output signal frequency in MHz. Range: 45-1002 MHz depending on delivery type * **Symbolrate**: Symbol rate in KBaud (kilobaud - thousands of symbols per second) * **FEC**: Forward Error Correction setting. Use default unless your streams require specific FEC * **Modulation**: Signal modulation type for the service ## Network Search [Section titled “Network Search”](#network-search) With network search configured, set-top boxes and TVs can use Quick Search instead of a full channel scan. This saves viewers time by avoiding lengthy channel searches. To set up Network Search: 1. Create all necessary MPTS streams and configure their Delivery Type parameters. For example: * mpts\_1 with frequency 378 MHz * mpts\_2 with frequency 386 MHz * mpts\_3 with frequency 394 MHz 2. Open settings for mpts\_1 and go to the NIT tab 3. Check all related multiplexes to include them in the network information 4. Save your settings ### How it works [Section titled “How it works”](#how-it-works) When a TV or set-top box finds frequency 378 MHz with `mpts_1`, it gets the NIT tables for all linked multiplexes and scans them quickly instead of searching every possible frequency. ## Modulators [Section titled “Modulators”](#modulators) Astra uses NIT settings to automatically configure DigitalDevices and TBS modulators defined in the MPTS Output List. When you set up NIT parameters in your MPTS stream, Astra applies these settings directly to the modulator hardware: * **Frequency**: Configures the RF output frequency on the modulator * **Symbolrate**: Sets the symbol rate for the modulated signal * **Modulation**: Applies the modulation scheme (QPSK, QAM16, QAM64, etc.) * **FEC**: Configures Forward Error Correction on the hardware This integration eliminates the need for separate modulator configuration, as Astra synchronizes your stream settings with the hardware automatically. # SDT Settings The SDT (Service Description Table) tab lets you configure information for each channel that viewers see on their devices.  * **Service type**: Type of service - digital television, digital radio, or data services * **Service name**: Channel name displayed on set-top boxes and TVs * **PNR**: Program Number - unique identifier for the service * **Scrambled channel**: Check this box if the channel is encrypted. * **LCN**: Logical Channel Number - controls the channel position in the list on set-top boxes and TVs Click the **＋** button to add a new channel into SDT. # Decrypt BISS BISS is a basic conditional access system with a static key to protect content from unauthorized access. ## Receiving a Scrambled Channel [Section titled “Receiving a Scrambled Channel”](#receiving-a-scrambled-channel) To decrypt a scrambled channel, you need to append the `biss` option with the appropriate key to the input address. For example: ```plaintext dvb://a001#pnr=1&biss=12345600789ABC00 ``` When using an invalid BISS key, the decrypted stream will be corrupted. In this case, the Astra analyzer will display a `PES Error`. ## Retransmitting Scrambled Channels [Section titled “Retransmitting Scrambled Channels”](#retransmitting-scrambled-channels) To retransmit a scrambled channel without decrypting it, you can use the `cas` option in the Input Address. Example of an Input Address with the `cas` option: ```plaintext dvb://a001#pnr=1&cas ``` This method allows you to pass the scrambled channel to the output, preserving all the necessary data required for descramblers to decode the content. # MPEG-TS Demultiplexing MPEG-TS Demultiplexing is the process of extracting individual audio, video, and data streams from a combined MPEG-TS broadcast, also known as multiplext or MPTS. ## Extracting single channel from multiplex [Section titled “Extracting single channel from multiplex”](#extracting-single-channel-from-multiplex) In digital TV broadcasting, the stream received from sources such as satellite, terrestrial, or cable networks contains multiple channels. To extract a single channel from this multiplex, Astra provides a specific option: `pnr`. For example, to receive a stream from a DVB Adapter with the identifier `a001` and extract channel number `1`, you would use the following input address: ```plaintext dvb://a001#pnr=1 ``` Astra forms this address automatically if you scan DVB Adapter and append channels with web interface. Read more: [Scan DVB Adapter](../../../adapters/scan/) and [Receiving MPTS via UDP](../../../receiving/udp/mpts-via-udp/) ## Filter service tables [Section titled “Filter service tables”](#filter-service-tables) In some cases you may want to remove service tables delivered with channel. To do that Astra has additional input options: * `no_eit`: removes Event Information Table (EIT). EIT provides Electronic Program Guide (EPG) * `no_sdt`: removes Service Description Table (SDT). SDT provides information about channel and delivery network * `no_tdt`: removes Time and Date Table (TDT). TDT provides current UTC date and time * `no_tot`: removes Time Offset Table (TOT). TOT provides current UTC date and time with offset information of the current region time zone Example: ```plaintext dvb://a001#pnr=1&no_sdt&no_eit ``` ## Pass service tables without modification [Section titled “Pass service tables without modification”](#pass-service-tables-without-modification) During the demultiplexing process, Astra keep in EIT and SDT tables information related to the selected channel only. If you want to pass packets as is, without any changes you may use next options: * `pass_eit`: pass EIT without changes * `pass_sdt`: pass SDT without changes These options are not recommended to use and they are incompatible with `set_pnr` and `set_tsid` options. ## Packets with private data [Section titled “Packets with private data”](#packets-with-private-data) During the demultiplexing process, Astra excludes packets containing unknown data and only allows Video and Audio streams to pass through. If you intend to retain private data, use option `pass_data`: ```plaintext dvb://a001#pnr=1&pass_data ``` ## Packets with conditional access data [Section titled “Packets with conditional access data”](#packets-with-conditional-access-data) During the demultiplexing process, Astra discards all packets and associated information related to the Conditional Access System (CAS). If you want to retain this data, use option `cas`: ```plaintext dvb://a001#pnr=1&cas ``` This option becomes essential when descrambling streams using dedicated CAM modules. Read more in our article: [Descrambling channels with External DVB-CI](../../../adapters/external-ci/) ## Change program number [Section titled “Change program number”](#change-program-number) To customize the Program Number (PNR), use option `set_pnr`: ```plaintext dvb://a001#pnr=1&set_pnr=1000 ``` PNR value could be in range from 1 to 65535. This feature could be useful if you want to prepare channel for next multiplexing. # Filter PIDs Stream Filtering removes specific packets within the MPEG-TS stream based on their PIDs. Additionally, the process modifies the corresponding program-specific information tables, such as Program Association Table (PAT) and Program Map Table (PMT), to reflect the removal of the identified packets. ## Analyze Channel [Section titled “Analyze Channel”](#analyze-channel) To identify available elementary streams and their PIDs, it’s necessary to analyze the channel. This can be achieved by launching the built-in MPEG-TS analyzer either from the channel menu or directly from the channel settings.  On the provided screenshot, we can see the following elementary streams: 1. Video - PID: `1331` 2. Subtitle - PID: `1335`, Language: `bul` (Bulgarian) 3. Audio - PID: `1332`, Language: `bul` (Bulgarian) 4. Audio - PID: `1336`, Language: `eng` (English) Each elementary stream is represented by a unique Packet Identifier (PID), which can be used for Stream Filtering in Astra. ## Input filtering [Section titled “Input filtering”](#input-filtering) In order to perform the stream filtering, we will drop the stream with PID 1336. This operation can be conducted by appending the `filter=1336` option to the input address  ## Inverse input filtering [Section titled “Inverse input filtering”](#inverse-input-filtering) To perform inverse filtering and remove all streams except those specified, you can use the tilde symbol (`~`) along with the filter option. For instance, to keep only the video stream and the English audio stream (PIDs 1331 and 1336), you would append the `filter~=1331,1336` option to the input address. This will remove all other streams, leaving only the defined streams. To verify the results of the applied stream filter, click “Apply” to save the changes. Next, launch the built-in MPEG-TS analyzer again. This will allow you to check if the unnecessary streams have been successfully filtered out.  ## Filtering for all inputs [Section titled “Filtering for all inputs”](#filtering-for-all-inputs) For stream filtering across all inputs, the `Remap` tab in the channel settings can be used. This method is suitable with the remap feature.  In the `Map PIDs` field, `video=101, audio.eng=102` has been set. This alters the PIDs of the video and English audio streams to 101 and 102, respectively, across all inputs. Subsequently, in the `Filter PID` field, `101, 102` has been specified. This implies that only the streams with these PIDs will be retained in the output, while all other elementary streams will be filtered out. Read more: [Remap PIDs](../remap/) # Reorder PIDs In this article, we will explore how to change the order of audio streams in a channel using Astra. When broadcasting a channel with multiple audio streams the order of the streams can be crucial for viewers convenience. Most TV and other media players automatically select the first audio stream by default. By reordering the audio streams, you can ensure that your preferred language is set as the default option. ## Analyze Channel [Section titled “Analyze Channel”](#analyze-channel) The first step in reordering audio streams is to analyze the channel and gather information about the available audio streams and their respective Packet Identifiers (PIDs). This will help you identify the current order of audio streams in your channel and make the necessary changes accordingly. To analyse the channel, follow these steps: 1. Open channel settings in the Astra Web Interface 2. Within the channel settings, click the `Analyze` button. This will initiate the channel analysis process 3. After a brief moment, the analyzer will display detailed information about the channel, including available audio streams and their PIDs  In the provided screenshot, we can see that there are video and two audio streams present: 1. VIDEO PID: `331` 2. AUDIO PID: `332`, Language: `eng` (English) 3. AUDIO PID: `333`, Language: `bul` (Bulgarian) Take note of the stream PIDs, as you will need this information to reorder the audio streams in the next step. ## Reorder Audio Streams [Section titled “Reorder Audio Streams”](#reorder-audio-streams) The final step in reordering audio streams is to modify the channel configuration. Close the channel analyzer by clicking the `Close` button. This will return you to the channel settings. To reorder the audio streams, follow these steps: 1. In the channel settings, locate the `Input` section. This is where you will find the input address for your channel 2. To change the order of the audio streams, append the following option to the input address: `order=331,333,332`. The order parameter should include the PIDs of the video stream first, followed by the default audio stream, and then any additional audio streams. In this example, the new order will be: Video (331), Bulgarian audio (333), and English audio (332) 3. Save the changes by clicking the `Apply` button at the bottom of the channel settings page  Tip Input options are separated by the `&` symbol, as shown in the example screenshot. The `#` symbol marks the beginning of the options. For instance, if your address does not have any options, the full address with the order options would be `udp://239.255.1.1:1234#order=331,333,332` # Remap PIDs Remapping Stream PIDs is beneficial in various scenarios: * Smooth Input Redundancy: If primary and backup inputs have differing PIDs for video and audio elementary streams, switching to the backup input may lead to a temporary interruption in playback. By remapping PIDs to ensure uniformity across primary and backup inputs, the transition can be made seamless. * Multi Program Stream (MPTS) Preparation: When preparing a channel for inclusion in an MPTS broadcast, each elementary stream within the channel must possess a unique PID. Remapping ensures this PIDs uniqueness, enabling smooth addition of the channel to the MPTS ## Analyze Channel [Section titled “Analyze Channel”](#analyze-channel) To identify available elementary streams and their PIDs, it’s necessary to analyze the channel. This can be achieved by launching the built-in MPEG-TS analyzer either from the channel menu or directly from the channel settings.  On the provided screenshot, we can see the following elementary streams: 1. Program Map Table (PMT) - PID: `374` 2. Video - PID: `371` 3. Audio - PID: `376`, Language: `eng` (English) Each elementary stream is represented by a unique Packet Identifier (PID), which can be used for Stream Remapping in Astra. ## Input remapping [Section titled “Input remapping”](#input-remapping) In order to perform the stream remapping, we will change the PMT PID to 100, the video stream PID to 101, and audio stream PID to 102. This operation can be conducted by appending the `map.pmt=100&map.video=101&map.audio.eng=102` option to the input address  ## Remapping for all inputs [Section titled “Remapping for all inputs”](#remapping-for-all-inputs) For stream remapping across all inputs, the `Remap` tab in the channel settings can be used.  In the “Map PIDs” field, `pmt=100, video=101, audio.eng=102` has been set. This alters the PIDs of the video and English audio streams to 101 and 102, respectively, across all inputs. To verify the results of the applied stream filter, click “Apply” to save the changes. Next, launch the built-in MPEG-TS analyzer again. This will allow you to check if the unnecessary streams have been successfully filtered out.  ## Selectors [Section titled “Selectors”](#selectors) Selector determinates what PID should be changed to the new value * `371`: any number as an original PID * `pmt`: PID for Program Map Table (PMT) * `video`: video stream * `audio`: any audio stream. You may define this option twice if you have several audio streams, for example: `video=101, audio=102, audio=103` * `audio.eng`: audio stream with defined language code * `ac3`: AC3 audio stream. The `audio` selector could be used for AC3 streams as well * `aac`: AAC audio stream. The `audio` selector could be used for ACC streams as well * `pcr`: PID for packets with PCR. Usually the PCR timestamp delivered with video stream packets * `sub`: subtitle stream * `ttx`: teletext stream * `ait`: PID for Application Information Table (AIT) # Advanced Settings  * **Enable monitoring**: analyze stream status and send reports to the monitoring system * **Channel Number**: option used to order channels in the playlist * **Start stream on demand**: Astra will wait for an incomming request to start stream. This mode is turned of for channels with UDP or HLS outputs * **Keep Active**: additional option for the on-demand mode. By default, when the last client is closes connection, Astra turns channel off. This option allows the channel to remain active for some time * **HLS Header**: custom HLS stream information for the `EXT-X-STREAM-INF` # Backup Settings Configure the redundancy behaviour to automatically switch stream inputs in case of a failure.  * **Backup Type**: redundancy behaviour type. Default: Active Backup * **Initial Delay**: delay in seconds before starting the next input after the stream has been initiated. Default: 5 for UDP or SRT; 10 for HLS, HTTP MPEG-TS, or RTSP; 120 for DVB * **Start Delay**: delay in seconds before starting the next input. Default: 5 * **Return Delay**: delay for Active Backup in seconds for returning to the previous input The built-in analyzer continuously monitors the active input, and if a fault is detected, it immediately switches to an alternate input. ## Active Backup [Section titled “Active Backup”](#active-backup) The default behavior is Active Backup. In the event of a failure, Astra switches to the next input while continuing to analyze the previous inputs for a potential switch back. If all inputs fail, Astra will continue to stream latest avilable input. To halt streaming, an additional option is available for the Backup Type: “Active Backup and Stop streaming if all inputs are inactive” ## Passive Backup [Section titled “Passive Backup”](#passive-backup) In the event of a failure, Astra switches to the next input and stops the previous input. If the last input fails, Astra will automatically switch back to the first input ## Disabled Backup [Section titled “Disabled Backup”](#disabled-backup) In the event of a failure, Astra does nothing. This method is suitable for manually switching inputs using the Web Interface or API methods. Read more in [Stream API → Switch active input](../../../api/stream/#switch-active-input) # EPG Export Settings Configure the EPG Export to extract Electronic Programme Guide from stream  * **XMLTV Channel ID**: use a custom channel ID instead of primary ID * **Format**: EPG Export format: * **XMLTV**: this is popular format is used for storing and distributing EPG. XMLTV is compatible with various middleware and IPTV players * **JSON**: useful for sending EPG to external servers or for direct use in a web application. For instance, it can be embedded on a website * **Destination**: destination for EPG Export: * **file**: save the EPG to a local file. For example, using `file:///tmp/test_channel.xml` will store the EPG in the `/tmp` directory with the filename `test_channel.xml` * **http**: sending EPG using an HTTP POST request. On the server side, an application is required to handle the received request, such as EPG Aggregator * **Codepage**: decode text from received EIT packets using defined codepage. Stored text is always encoded with UTF-8 ## EPG Aggregator [Section titled “EPG Aggregator”](#epg-aggregator) EPG Aggregator is a script for Astra to receive EPG from many servers and save it into the single XMLTV file. ### Install [Section titled “Install”](#install) To install script, download it and save on the server. You may do that with `curl` command on the server: ```sh curl -Lo /etc/astra/epg-aggregator.lua https://cdn.cesbo.com/astra/scripts/epg-aggregator/epg-aggregator.lua ``` ### Start script with Systemd [Section titled “Start script with Systemd”](#start-script-with-systemd) To start script automatically you may append it to the systemd. 1. Download configuration file: 2. In this file you may configure command line arguments 3. Save file on your server to `/etc/systemd/system/astra-epg.service` 4. Start script: `systemctl start astra-epg` 5. Enable autorun: `systemctl enable astra-epg` Command line arguments: * `-o /tmp/epg.xml`: full path to store generated XMLTV file * `-p 5000`:port for receiving requests from Astra * `–daemon`: run as daemon * `–interval SEC`: interval of saving EPG to file. default: 60 seconds * `–stalker`: replace tag `` to `` for middleware Stalker/Ministra Script is ready to receive requests from Astra ### Configure Astra for EPG Aggregator [Section titled “Configure Astra for EPG Aggregator”](#configure-astra-for-epg-aggregator) In stream settings, on the “EPG” tab, configure the EPG Export: * `Format`: set `JSON` * `Destination`: set `http://EPG_aggregator_IP:5000` XMLTV file with the collected data will be located on the path: `/tmp/epg.xml`. Also you may download XMLTV from http\://EPG\_aggregator\_IP:5000/epg.xml or you may append this URL to the client application. ### Restart EPG Aggregator nightly [Section titled “Restart EPG Aggregator nightly”](#restart-epg-aggregator-nightly) In some cases you may need to restart EPG Aggregator, better to do that nightly. You may do that with a system scheduler - cron. Open cron configuration: ```plaintext sudo crontab -e ``` and append line to the file: ```plaintext 0 4 * * * systemctl restart astra-epg ``` Save changes in cron. Collector will restart each night at 4:00 # Remap Settings The Remap feature in Astra allows modify the Packet Identifier (PID) for MPEG-TS elementary streams.  * **Map PID’s**: modify the Packet Identifier (PID) for MPEG-TS elementary streams. Read more in [How to Remap PIDs](../../processing/remap/) * **Filter PID’s**: removes specific packets within the MPEG-TS stream based on their PIDs. Read more in [How to Filter PIDs](../../processing/filter/) * **Change PNR**: change program number. Program number could be in range from 1 to 65535 * **Change TSID**: change transport stream identifier # Service Settings The Service Settings offers options to customize the stream information delivered to the players.  * **Service Type**: type of the service, video, radio or some other * **Service Provider**: name of your service provider, which can be defined globally under Settings → General → Service Provider * **Service Name**: public name of the service, which will be displayed on the TV * **Codepage**: text encoding used for the Service Provider and Service Name options * **HbbTV URL**: append URL to the HbbTV (Hybrid broadcast broadband TV) for the delivery of advanced interactive TV features * **Conditional Access**: protecting a stream using a Condition Access System to prevent unauthorized access. Read more in [CAS and Simulcrypt](../../../delivery/broadcast/cas-and-simulcrypt/) # Terms of Use *Last updated: Nov 27, 2025* Please read these terms and conditions carefully before using Our Software. ## Astra [Section titled “Astra”](#astra) Astra is server-side software used to receive, process, and deliver digital TV streams. Astra itself does not provide any content. It is only a technical tool, and all responsibility for the sources, content, and distribution of the streams lies fully with the user. ### System requirements [Section titled “System requirements”](#system-requirements) * **CPU**: Intel or AMD x86 64-bit * **Operation system**: Any 64-bit Linux based distributions. Recommended: Ubuntu 22.04 LTS Your server shall have access to the Internet. Astra uses next servers to validate license: ls1.cesbo.com, ls2.cesbo.com, ls3.cesbo.com. Astra validates license serial number and unique hardware identifier on launch. Astra do not send any other information to our servers! ### Licenses [Section titled “Licenses”](#licenses) Astra has three licensing options: * **Demo**: a free license to try all features for 40 days. For evaluation only, not commercial use * **Subscription**: a paid license with monthly or yearly billing. Includes technical support and regular updates. You can cancel your subscription at any time * **Lifetime**: a paid license with one-time payment for permanent use. No updates - works with [versions](../quick-start/versions/) released before your purchase date. You can upgrade anytime to get the latest version Each license includes a server limit. You can run Astra on as many servers as your license allows. For example, a 5-server license lets you install and use Astra on up to 5 different servers. There is no limit on the number of Astra processes you can run on a single server. ## Technical support [Section titled “Technical support”](#technical-support) We offer support free of charge for quick questions related to sales, as well as assistance with first-time installation and issues with our website. However, technical support is only provided to customers who have purchased a Subscription or Lifetime license. We strive to respond to all support requests as quickly as possible, though we don’t currently offer priority support. Rest assured that we will reply to your request as soon as we can. In order to help us prioritize your request, we have a set of guidelines that we follow: * The highest priority have issues related to bugs in our software * Issues with the environment in which our software operates, such as channels for receiving and processing data, hardware, and network issues * Features requests * Maintenance tasks such as installation, configuration and updating ## Purchase [Section titled “Purchase”](#purchase) In the license price included only software. We don’t offer access to the channels, hosting services, etc. We have good discounts for subscription. License cost depends of the subscription period and number of servers. **Attention!** We do not offer refunds. You can try the full-featured version for free ### VAT [Section titled “VAT”](#vat) VAT - is an European Union (EU) Value-Added Tax. The EU Customers order may be subject to VAT at the rate applicable in your EU Member State ### Credit Cards [Section titled “Credit Cards”](#credit-cards) We accept all major debit and credit cards. Our payment gateway providers ensures that all transactions are secure and protected: * [Stripe](https://stripe.com) ### PayPal [Section titled “PayPal”](#paypal) We also support PayPal payments. PayPal supports more credit card providers and as well as bank transfers. ### Our Partners [Section titled “Our Partners”](#our-partners) In addition to the above payment methods, our partners in several countries offer local payment options: * 🇧🇾 Belarus. PE TVABY * 🇷🇺 Russia. SP Vera Dyldina * 🇺🇦 Ukraine. TK CESBO LLC * 🇩🇪 Germany. Showeikh International GmbH * 🇩🇪 Germany. Digital Devices Distribution GmbH ## Disclaimer [Section titled “Disclaimer”](#disclaimer) THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ## Content Responsibility [Section titled “Content Responsibility”](#content-responsibility) The user is solely responsible for all content received, processed, stored, or distributed through Astra. The software does not include or provide any media content, channels, or sources. The user must ensure that all content usage complies with applicable laws, regulations, and licensing requirements. # Launch Astra in Console If your system does not have systemd you may launch process manually: ```sh astra -c /etc/astra/astra.conf -p 8000 ``` Process will be launched in the foreground and your console will be taken by process until it finish. To stop process just press Ctrl+C on your keyboard. * `-c`: path to the configuration file. * `-p`: port for the Astra Web Interface. ## Launch in background [Section titled “Launch in background”](#launch-in-background) To launching process in background append option `--daemon` after the command line: ```sh astra -c /etc/astra/astra.conf -p 8000 --daemon ``` ## Kill process [Section titled “Kill process”](#kill-process) Process will be launched in the background and console will be returned to your control immediately. To stop process you may launch command: ```sh killall astra ``` ## Path to license file [Section titled “Path to license file”](#path-to-license-file) By default, Astra will look for the license file in the `/etc/astra/license.txt` path. If you have your license file in a different location, you can specify it using the `--license` option when launching Astra. ```sh astra -c /etc/astra/astra.conf -p 8000 --license /path/to/license.txt ``` # Astra DVB List Astra DVB List is a simple built-in tool to get information about installed DVB adapters. ## Usage [Section titled “Usage”](#usage) ```plaintext astra --dvbls [OPTIONS] ``` Availabale options: * `-o FILE` - export dvb list to the file After start program print information about adapters to the console. Adapter available to use: ```plaintext Nov 10 09:00:00: INFO: adapter = 3, device = 0 Nov 10 09:00:00: INFO: mac = 00:17:42:00:00:00 Nov 10 09:00:00: INFO: frontend = Montage DS3103/TS2022 Nov 10 09:00:00: INFO: type = S ``` Adapter is taken: ```plaintext Nov 10 09:00:00: WARNING: adapter = 2, device = 0 Nov 10 09:00:00: WARNING: adapter in use Nov 10 09:00:00: WARNING: mac = 00:17:42:00:00:00 Nov 10 09:00:00: WARNING: frontend = Montage DS3103/TS2022 Nov 10 09:00:00: WARNING: type = S ``` An error occurred while accessing the device. Some hardware malfunction or you need to reinstall the driver: ```plaintext Nov 10 09:00:00: ERROR: adapter = 1, device = 0 Nov 10 09:00:00: ERROR: failed to open [Bad file descriptor] ``` ## Export DVB list to the file [Section titled “Export DVB list to the file”](#export-dvb-list-to-the-file) When Astra starts up, it retrieves information about the DVB adapters installed on the system. In some rare cases, this operation can take a long time. To prevent Astra from updating this information on each start, you can save it to a file. To do this, follow these steps: Create directory for Astra scripts: ```plaintext mkdir -p /etc/astra/mod ``` Export the DVB list to a Lua file: ```plaintext astra --dvbls -o /etc/astra/mod/dvb.lua ``` # EIT Stream EIT Stream is a tool to convert XMLTV files into MPEG-TS stream with Event Information Tables (EIT) for broadcasting networks like DVB, ATSC, ISDB. ## Installation [Section titled “Installation”](#installation) Just download single binary file and set execute permission: ```sh curl -Lo /usr/bin/eit-stream http://cesbo.com/and/eit-stream chmod +x /usr/bin/eit-stream ``` ## Configuration [Section titled “Configuration”](#configuration) Create a configuration file `/etc/eit-stream.conf` with any text editor. Example: ```ini xmltv = /opt/xmltv.xml output = udp://lo@239.0.0.1:1234 onid = 8000 codepage = 5 eit-days = 1 eit-rate = 1500 [tdt-tot] country = EST offset = +120 # First multiplex [multiplex] tsid = 1 [multiplex/service] pnr = 101 xmltv-id = discovery [multiplex/service] pnr = 102 xmltv-id = history # Second multiplex [multiplex] tsid = 2 xmltv = /opt/xmltv-2.xml [multiplex/service] pnr = 201 xmltv-id = euronews ``` Lines started with symbol `#` is a comment and ignored. ### General options [Section titled “General options”](#general-options) * `xmltv` - path to local xmltv file. or http/https link to xmltv or gzip xmltv file. This option could be redefined in `[multiplex]` or in `[multiplex/service]` * `output` - destination UDP address * `onid` - original network identifier * `codepage` - codepage. This option could be redefined in `[multiplex]` or in `[multiplex/service]` * `eit-days` - number of days in epg. default is 3 * `eit-rate` - bitrate in kbit/s. default 15 kbit/s per each service ### Supported codepages [Section titled “Supported codepages”](#supported-codepages) Next codepages available for text encoding: * `0` - Default. Latin (ISO 6937) * `1` - Western European (ISO 8859-1) * `2` - Central European (ISO 8859-2) * `3` - South European (ISO 8859-3) * `4` - North European (ISO 8859-4) * `5` - Cyrillic (ISO 8859-5) * `6` - Arabic (ISO 8859-6) * `7` - Greek (ISO 8859-7) * `8` - Hebrew (ISO 8859-8) * `9` - Turkish (ISO 8859-9) * `10` - Nordic (ISO 8859-10) * `11` - Thai (ISO 8859-11) * `13` - Baltic Rim (ISO 8859-13) * `14` - Celtic (ISO 8859-14) * `15` - Western European (ISO 8859-15) * `21` - UTF-8 ### Time and date options [Section titled “Time and date options”](#time-and-date-options) Section `[tdt-tot]`: * `country` - country code in format ISO 3166-1 alpha-3 * `offset` - the signed time offset in minutes from GMT. For example +120 is GMT+2 or -300 is GMT-5 ### Multiplex options [Section titled “Multiplex options”](#multiplex-options) Section `[multiplex]` * `tsid` - multiplex transport stream identifier * `name` - optional field to describe multiplex ### Service options [Section titled “Service options”](#service-options) Section `[multiplex/service]` * `pnr` - channel number/pnr * `xmltv-id` - channel id in xmltv * `parental-rating` - age restriction. Value defined in pairs: country and age. For example: `parental-rating = EST 16 USA 14`. Country code in ISO 3166-1 alpha-3 format (3 letters). Age from 4 to 18 (inclusive), 0 - without restrictions. ## Mux stream with EIT to MPTS [Section titled “Mux stream with EIT to MPTS”](#mux-stream-with-eit-to-mpts) With Astra you can append UDP stream with EIT to the MPTS. In the MPTS settings append input and set UDP address, for example in configuration above address is `udp://lo@239.0.0.1:1234`. In the MPTS advanced settings turn on option “Pass EIT”. Use `no_eit` option on other inputs to disable EIT from other inputs. ## Autostart [Section titled “Autostart”](#autostart) Register service in systemd to start service in background and autostart on system startup. Create file `/etc/systemd/system/eit-stream.service`: ```ini [Unit] Description=eit-stream service After=network-online.target [Service] Type=simple ExecStart=/usr/bin/eit-stream /etc/eit-stream.conf KillMode=process Restart=on-failure [Install] WantedBy=multi-user.target ``` Next command could be used to manage service: * start service: `systemctl start eit-stream` * stop service: `systemctl stop eit-stream` * enable auto-start: `systemctl enable eit-stream` * disable auto-start: `systemctl disable eit-stream` ## Reload [Section titled “Reload”](#reload) To restart service once at night append next line into /etc/crontab: ```plaintext 0 2 * * * root systemctl restart eit-stream ``` ## XMLTV Format [Section titled “XMLTV Format”](#xmltv-format) XMLTV is an XML-based format for describing TV schedule information. It provides a mechanism to store channel information, programme schedules, and their associated metadata. ```xml Channel 1 Channel 2 Program description 1 Program release date 1 Category 1 Category 2 Program description 2 Program release date 2 Category 1 Program description 3 Program release date 3 Category 1 Category 2 ``` # Astra HTTP Relay Astra HTTP Relay is a simple built-in tool to retransmit data from any source supported by Astra to HTTP client. ## Usage [Section titled “Usage”](#usage) ```plaintext astra --relay -p 8000 ``` Command line arguments: * `-p 8000` - local port for incomming connections. Default: `8000`; * `-a 0.0.0.0` - local IP address for incomming connections. Default `0.0.0.0` - accept request on any interface; * `-l 0.0.0.0` - IP address of the local interface to receive UDP/RTP streams. Default `0.0.0.0` - receives streams according to system routing table; * `--pass login:password` - login and password for basic authorization for all requests; * `--no-udp` - disable access to the UDP/RTP source; * `--no-http` - disable access to the HTTP source; * `--buffer-size 1024` — the maximum buffer size in kilbytes for each client. Default 1024Kb; * `--buffer-fill 128` — defines number of kilobytes to fill in buffer before start transmission. Default 128Kb; * `--daemon` - start in daemon mode; * `--log` /var/log/relay.log - full path to the log file; * `--channels /etc/astra/relay.lua` - full path to the channel aliases. ## Address format [Section titled “Address format”](#address-format) Request address has next format: * `http://your-server-address:8000/udp/239.255.1.1:1234` - receives UDP stream from multicast group `239.255.1.1:1234` * `http://your-server-address:8000/http/example.com/travel-channel` - receives HTTP stream from `http://example.com/travel-channel` ## Channel aliases [Section titled “Channel aliases”](#channel-aliases) Channel aslias let to use short name instead of full address. Alias list example: ```plaintext -- /etc/astra/relay.conf channels = { ["demo"] = "udp://239.255.1.1:1234", ["travel-channel"] = "http://example.com/travel-channel" } ``` Launch relay with path to the alias list: ```plaintext astra --relay -p 8000 --channels /etc/astra/relay.conf ``` Channels from example above will be availble on: * `http://your-server-address:8000/demo` - UDP stream * `http://your-server-address:8000/travel-channel` - HTTP stream ## Statistics [Section titled “Statistics”](#statistics) Statistics is a simple page with active sessions contain next information: * Client IP address * Request path - alias or full address of the source channel * Uptime * Link to close session To view statistics, open in your browser: `http://your-server-address:8000/stat/` # Mosaic: Channel Screenshots on Dashboard Mosaic is a simple script to create channel screenshots with ffmpeg and set them on Astra Dashboard using Astra API. Channel Screenshots helps to visually evaluate quality of the channels.  ## Requirements [Section titled “Requirements”](#requirements) * Astra with enabled [HTTP Play](../../delivery/http/http-play/) * FFmpeg ## Install FFmpeg [Section titled “Install FFmpeg”](#install-ffmpeg) Install FFmpeg with system packet manager: ```sh apt install ffmpeg ``` ## Configure HTTP Play [Section titled “Configure HTTP Play”](#configure-http-play) On you server create new directory to store screenshot images: ```sh mkdir -p /var/lib/astra/mosaic ``` Then open Astra Web interface -> Settings -> HTTP Play:  Turn on HTTP Play if disabled and set path to the screenshots directory. Done, HTTP Play now configured and you may save changes. Also in the HTTP Play settings you may copy link to the `playlist.m3u8`, this file contains links to all enabled channel. Link to playlist lookls like: `https://example.com:8000/playlist.m3u8` If you use HTTP Authorization, set Token for administrator. Open Astra Web Interface -> Settings -> Users -> select administrator, and set any Token, for example: `c6017ac9`. Append this token to the playlist URL: `https://example.com:8000/playlist.m3u8?token=c6017ac9` ## Download and Configure Script [Section titled “Download and Configure Script”](#download-and-configure-script) [Download](https://cdn.cesbo.com/astra/scripts/mosaic/mosaic.sh) script and save it on your server: ```sh curl -Lo /usr/local/bin/mosaic.sh https://cdn.cesbo.com/astra/scripts/mosaic/mosaic.sh chmod +x /usr/local/bin/mosaic.sh ``` Open script with any text editor and modify following variables: * `THREADS` - number of threads to concurrently capture multiple screenshots. Fewer threads will take more time to update all images, while more threads will increase CPU usage. You may set as many threads as you have CPU cores * `PLAYLIST_URL` - URL to `playlist.m3u8` file from previous step * `SCREENSHOT_PATH` - path to store screenshots on your server: `/var/lib/astra/mosaic/` * `API_PORT` - port to Astra API * `API_AUTH` - admin login and password to access Astra API ## Start script with Systemd [Section titled “Start script with Systemd”](#start-script-with-systemd) To start script automatically you may append it to the systemd. Download configuration file for systemd and save it on your server: ```sh curl -Lo /etc/systemd/system/mosaic.service https://cdn.cesbo.com/astra/scripts/mosaic/mosaic.service ``` Next commands could be used to manage script: * Start script: `systemctl start mosaic` * Stop script: `systemctl stop mosaic` * Enable autorun: `systemctl enable mosaic` * Disable autorun: `systemctl disable mosaic` After the start check that new png files are creating in the screenshots directory: ```sh ls /var/lib/astra/mosaic ``` ## Uninstall [Section titled “Uninstall”](#uninstall) To uninstall Mosaic script, stop the service and remove the script and service file: ```sh systemctl stop mosaic systemctl disable mosaic rm /usr/local/bin/mosaic.sh rm /etc/systemd/system/mosaic.service ``` Remove screenshots directory: ```sh rm -r /var/lib/astra/mosaic ``` # MPEG-TS Analyzer Astra MPEG-TS Analyzer is built-in tool to analyze MPEG-TS streams.  ## Launch with Web Interface [Section titled “Launch with Web Interface”](#launch-with-web-interface) ```plaintext astra --analyze [OPTIONS] -p PORT ``` Options: * `-p PORT` - specify the port to use for web interface; * `-c FILE` - specifies the path to the channel list, which will be created automatically. This option allows you to save analyzed addresses; * `--daemon` - start in daemon mode; * `--log` /var/log/relay.log - full path to the log file. ## Launch in console [Section titled “Launch in console”](#launch-in-console) ```plaintext astra --analyze [OPTIONS] ADDRESS ``` Options: * `-n seconds` - stop analyzer after defined time * `-o file` - save stream received stream to the file Astra logs information directly to the console. For example: ```plaintext > astra --analyze "udp://239.255.1.1:1234" Nov 28 00:59:28: INFO: [main] Starting Astra (commit:b871b4e3 date:2022-01-12) Nov 28 00:59:29: INFO: PAT tsid:1 version:1 Nov 28 00:59:29: INFO: PAT PMT pid:115 pnr:1 Nov 28 00:59:29: INFO: PAT crc32:0x02575D2D Nov 28 00:59:29: INFO: PMT pnr:1 version:1 Nov 28 00:59:29: INFO: PCR pid:215 Nov 28 00:59:29: INFO: VIDEO pid:215 type:0x1B Nov 28 00:59:29: INFO: AUDIO pid:315 type:0x04 Nov 28 00:59:29: INFO: AUDIO lang:eng Nov 28 00:59:29: INFO: PMT crc32:0x9E87CF44 Nov 28 00:59:29: INFO: SDT tsid:1 version:3 Nov 28 00:59:29: INFO: SDT pnr:1 Nov 28 00:59:29: INFO: SDT provider:Demo TV Nov 28 00:59:29: INFO: SDT service:Demo1 Nov 28 00:59:29: INFO: SDT crc32:0x9F98BF46 Nov 28 00:59:30: INFO: EIT tsid:1 onid:1 pnr:1 version:17 Nov 28 00:59:30: INFO: EIT start:Wed Nov 28 00:10:00 2018 Nov 28 00:59:30: INFO: EIT stop:Wed Nov 28 01:05:00 2018 Nov 28 00:59:30: INFO: EIT lang:eng title:DOCUMENTARY Nov 28 00:59:30: INFO: EIT crc32:0xC0BCCA18 Nov 28 00:59:30: INFO: Bitrate: 2323 Kbit/s Nov 28 00:59:30: INFO: EIT tsid:1 onid:1 pnr:1 version:17 Nov 28 00:59:30: INFO: EIT start:Wed Nov 28 01:05:00 2018 Nov 28 00:59:30: INFO: EIT stop:Wed Nov 28 03:05:00 2018 Nov 28 00:59:30: INFO: EIT lang:eng title:AUDIENCE (16+) Nov 28 00:59:30: INFO: EIT crc32:0xE9257DFA Nov 28 00:59:31: INFO: Bitrate: 2397 Kbit/s Nov 28 00:59:32: INFO: Bitrate: 2755 Kbit/s Nov 28 00:59:33: INFO: Bitrate: 4446 Kbit/s ``` ## Address format [Section titled “Address format”](#address-format) Analyzer supports any receiving format supported by Astra. For example: * `udp://239.255.1.1:1234` * `http://example.com/media.m3u8` * `dvb://#adapter=0&type=s2&tp=11044:v:43200` More information described in the Astra Settings: Input # SSH: Basics SSH - is the primary protocol and tool for the remote servers management. Also allows you to create tunnels and transfer files. ## SSH Utilities [Section titled “SSH Utilities”](#ssh-utilities) ### OpenSSH Server [Section titled “OpenSSH Server”](#openssh-server) * `sshd` (OpenSSH Daemon): A server-side daemon that listens for incoming SSH connections. Authenticates users and establishes secure sessions. * `sftp-server` (SFTP server subsystem): A program for file transfers using the SFTP protocol, usually invoked automatically by the sshd daemon. ### OpenSSH Client [Section titled “OpenSSH Client”](#openssh-client) * `ssh` (SSH client): Logs into a remote server, provides virtual terminal, and executes commands. * `ssh-keygen`: Creates and manages authentication keys. * `scp`: Copies files between local and remote machines using an encrypted channel. * `sftp`: Transfers files over a secure channel, similar to FTP. ## Connection to server [Section titled “Connection to server”](#connection-to-server) ```bash ssh root@example.com ``` Connect to the server with custom port: ```bash ssh -p 2222 root@example.com ``` Connect to the server with a specific private key: ```plaintext ssh -i ~/.ssh/server_ed25519 root@example.com ``` ## Client Configuration [Section titled “Client Configuration”](#client-configuration) The SSH client can work without a configuration file and retrieve all the necessary parameters from command-line arguments. However, you may create a configuration file named `~/.ssh/config`. This file should contain the following information: ```plaintext Host example.com HostName 192.168.1.1 User root Port 2222 IdentityFile ~/.ssh/server_ed25519 ``` * `Host`: server name. This is the name used in the connection command: `ssh example.com` * `HostName`: an optional server address. If HostName is not defined, the proper address or host name should be defined in `Host` * `User`: username * `Port`: the server port. Default: `22` * `IdentityFile`: an optional field that specifies the full path to the private key file ## SSH Keys [Section titled “SSH Keys”](#ssh-keys) SSH keys are a more secure way of logging into an SSH server, compared to using passwords. They consist of a pair of keys: a public key and a private key. The public key is placed on the server you want to connect to, while the private key remains on your local machine. Caution Do not share your private keys! ### Generating [Section titled “Generating”](#generating) To generate an SSH key pair, use the following command: ```bash ssh-keygen -t ed25519 -f ~/.ssh/server_ed25519 ``` * `ed25519` - selects the type of encryption. Ed25519 is the optimal choice * `~/.ssh/server_ed25519` - the path to the private key file. The public key will be generated as `~/.ssh/server_ed25519.pub` Once the command is started, it will prompt you to enter a password. This password provides an additional level of security and must be entered when connecting to the server. The public key is a single line with the following format: ```plaintext ssh-ed25519 AAAA...UUUU user@example.com ``` ### Copy Public Key to Server [Section titled “Copy Public Key to Server”](#copy-public-key-to-server) On the server side, append this line to the `~/.ssh/authorized_keys` file. This file may contain one or more keys. To append the public key, run the following command: ```bash echo "ssh-ed25519 AAAA...UUUU user@example.com" >>~/.ssh/authorized_keys ``` ## SSH Agent Forwarding [Section titled “SSH Agent Forwarding”](#ssh-agent-forwarding) SSH Agent forwarding allows you to use your local SSH keys on a remote server without sharing. This is useful when you need to access another server from the first server without storing your keys on the remote server. You can enable SSH Agent forwarding by using the -A option with the ssh command: ```bash ssh -A example.com ``` Alternatively, you can enable it permanently for a specific host in your SSH config file `~/.ssh/config`: ```plaintext Host example.com ForwardAgent yes ``` Note SSH Agent will be forwarded only in active SSH session, and the private key will not be copied to the remote server. SSH Agent forwarding is not recommended for untrusted servers. # SSH: Tunnels > Port forwarding with SSH SSH tunnels are a powerful tool for secure communication, bypassing network restrictions, providing remote access to local resources. ## Local Port Forwarding [Section titled “Local Port Forwarding”](#local-port-forwarding) Local port forwarding allows you to forward a port on your local machine to a remote address and port. Imagine you have a web application running on a remote server with address `127.0.0.1:8000`. To access this web application from your local machine, you can use SSH port forwarding: ```bash ssh -L 8080:127.0.0.1:8000 example.com ``` Now in the web browser on the local machine go to `http://localhost:8080` and you should get the data (or see the web page) from your remote server. * `8080` - the port number on the local computer with ssh client * `127.0.0.1:8000` - the IP address and port number on the remote computer * `-fNT` - additional options to run the SSH client in the background ## Reverse Port Forwarding [Section titled “Reverse Port Forwarding”](#reverse-port-forwarding) Reverse port forwarding allows you to forward a port on the remote server to a local service. For example, to forward remote port 9090 to your local machine’s port 3000: ```bash ssh -R 9090:localhost:3000 example.com ``` Now all request on the remote server to port `9090` will be forwarded to port `3000` on your local machine. ## SSH Proxy Jump [Section titled “SSH Proxy Jump”](#ssh-proxy-jump) ProxyJump is another useful mechanism. It allows you to connect to a remote server via an intermediate SSH server, also known as a “jump host”. To connect to server2 via server1: ```bash ssh -J user@server1 server2 ``` Alternatively, you can enable it permanently for a specific host in your SSH config file `~/.ssh/config`: ```plaintext Host server2 ProxyJump user@server1 ``` Now you can simply use: ```bash ssh server2 ``` ## Examples [Section titled “Examples”](#examples) ### Secure Remote Database Access [Section titled “Secure Remote Database Access”](#secure-remote-database-access) **Scenario**: You have a MySQL database running on a remote server and you want to access it from your local machine. Create an SSH tunnel to forward the remote MySQL port to your local machine: ```bash ssh -L 3306:localhost:3306 example.com ``` After running this command, you can connect to the remote MySQL database using a local MySQL client like so: ```bash mysql -h 127.0.0.1 -P 3306 -u db_user -p ``` ### Tunneling Multiple Ports [Section titled “Tunneling Multiple Ports”](#tunneling-multiple-ports) **Scenario**: You need to access a remote database on port `5432` and a web application on port `8080` on remote server. ```bash ssh -L 8080:localhost:8080 -L 5432:localhost:5432 example.com ``` After running this command, you can access the remote web application at `http://localhost:8080` and the remote database at `localhost:5432`. ### Tunneling with an SSH Config File [Section titled “Tunneling with an SSH Config File”](#tunneling-with-an-ssh-config-file) For frequent SSH tunnel setups, you can configure your SSH client to simplify the process using the SSH config file `~/.ssh/config`. ```plaintext Host example.com LocalForward 5432 localhost:5432 LocalForward 8080 localhost:8080 ``` This setup allows you to quickly establish SSH tunnels with predefined configurations by simply using the aliases. ### Access to IP Camera in a Private Network [Section titled “Access to IP Camera in a Private Network”](#access-to-ip-camera-in-a-private-network) **Scenario**: You have an IP camera on a private network that streams video over RTSP on `rtsp://192.168.1.10:554/stream1`. You need to access this RTSP stream from your local machine. ```bash ssh -L 8554:192.168.1.10:554 example.com ``` After running this command, you can access the RTSP stream from your local machine using an RTSP client (e.g., VLC media player) by connecting to `rtsp://localhost:8554/stream1`. 1. Open VLC Media Player 2. Go to “Media” and click “Open Network Stream”. 3. Enter the URL `rtsp://localhost:8554/stream1`. 4. Click “Play”. VLC will now connect to the RTSP stream through the SSH tunnel, allowing you to view the camera feed as if you were on the same private network as the camera. # DVB Driver Issues > This guide helps you solve common problems with DVB drivers on Linux. You will learn how to check if adapters are detected, fix issues after kernel updates, and configure driver options. This guide helps you solve common problems with DVB drivers on Linux. You will learn how to check if adapters are detected, fix issues after kernel updates, and configure driver options. ## failed to open frontend: No such file or directory [Section titled “failed to open frontend: No such file or directory”](#failed-to-open-frontend-no-such-file-or-directory) Most common issue with DVB adapters is that they stop working after server reboot. Probably Linux kernel has been updated with autoupdate or manually. The first step is to check whether the DVB adapters are present in the system using the command: ```sh ls /dev/dvb ``` If the command shows an error message “No such file or directory”, the first thing to do is to check if the hardware is available to the system using the command: ```sh lspci | grep Multimedia ``` If the adapters are properly connected to the PCIe slot, you should see a listing of the PCIe adapters like this: ```plaintext 01:00.0 Multimedia controller: Digital Devices GmbH Cine V7 ``` Try to reinstall the driver. If this doesn’t help, please contact the hardware vendor. * [DigitalDevices Driver Installation](../../adapters/dd-driver/) * [TBS Driver Installation](../../adapters/tbs-driver/) ## Secure Boot [Section titled “Secure Boot”](#secure-boot) If the `/dev/dvb` folder is empty or not found, try to start driver manually. Launch in your console: ```plaintext modprobe dvb-core ``` If you got error: ```plaintext modprobe: ERROR: could not insert 'dvb_core': Required key not available ``` This error message is related to Secure Boot. 1. Restart your system and enter the system’s BIOS/UEFI settings. 2. Navigate to the Secure Boot configuration page (the exact position varies based on the manufacturer and BIOS/UEFI version). 3. Disable the Secure Boot option. 4. Save changes and exit. 5. Boot into Linux again and check adapters with `ls /dev/dvb` ## Signal is fine, but channels not working [Section titled “Signal is fine, but channels not working”](#signal-is-fine-but-channels-not-working) This issue common for adapters by DigitalDevices. Check dmesg output for i2c errors: ```sh dmesg | grep i2c ``` if you see messages like i2c\_write error then turn off MSI (Message Signaled Interrupts) in the driver: Open file `/etc/modprobe.d/ddbridge.conf` in any text editor. Find line `options ddbridge`. After the `ddbridge` append `msi=0` option. For example: ```plaintext options ddbridge msi=0 fmode=1 ``` # BER/UNC Error on DVB Adapters Common metrics like signal level and signal-to-noise ratio (SNR) indicate the broad status of signal reception, but are not sufficient for diagnosing specific reception problems. ## BER [Section titled “BER”](#ber) BER (Bit Error Rate) is a metric used to quantify the number of bits that are incorrectly received or decoded in a given transmission. The BER error is an expression of the number of incorrect bits as a ratio or percentage of the total number of bits transmitted. In DVB systems, the BER error is an important metric for measuring the quality of the received signal. A low BER indicates a good signal quality with fewer errors, while a high BER suggests that the signal quality is poor and more errors are present in the transmitted data. Factors such as noise, interference, signal strength, and transmission distance can all affect the BER. To improve the BER, DVB systems often employ various error-correcting techniques, such as Forward Error Correction (FEC), which can detect and correct errors in the transmitted data, enhancing the overall quality and reliability of the digital signal. ## UNC [Section titled “UNC”](#unc) UNC (Uncorrectable Error) indicates that a received data packet contains errors that cannot be corrected by the error-correction mechanisms employed in the system, such as Forward Error Correction (FEC). Typically, digital communication systems use FEC to detect and correct errors in transmitted data. However, if the number of errors within a data packet is too high, or if the errors are too severe, the FEC mechanisms may fail to correct them. In such cases, the system reports an UNC error. UNC errors can result from various factors, including poor signal quality, high noise levels, interference, or problems with the transmission equipment. High levels of UNC errors may lead to degraded video or audio quality, freezing or pixelation in digital TV broadcasts, or even loss of signal. To minimize UNC errors, it’s essential to: 1. Consider sun interference - Periodic signal degradation, also known as solar outage or sun fade, can occur when the sun aligns directly behind the satellite, causing increased noise levels and temporary signal disruption. Read more: [Solar Interference on Satellite Reception](../solar-interference/) 2. Check the dish alignment and LNB - Connect a signal analyzer directly to the LNB using a short cable 3. Connect the signal analyzer to the cable on the receiver side. The coaxial cable insulation may be damaged or compromised # CAM Troubleshooting > Common issues with DVB-CI and Conditional Access Modules (CAM) Conditional Access Modules (CAM) are used with DVB-CI to descramble encrypted channels. Sometimes CAMs may not work as expected. Below are the most common issues and how to check them. ## CI+ modules not supported [Section titled “CI+ modules not supported”](#ci-modules-not-supported) CI+ modules are designed for consumer devices like TVs and set-top boxes. They are not supported in professional headend use with Astra. Only standard DVB-CI modules are compatible. ## Only one channel descrambled [Section titled “Only one channel descrambled”](#only-one-channel-descrambled) Many CAMs can descramble only one channel at a time. Some models support **multi-service descrambling**, but the exact number depends on the CAM manufacturer and firmware. If you see only one clear channel while others remain encrypted, this is a CAM limitation. ## How to check CAM menu [Section titled “How to check CAM menu”](#how-to-check-cam-menu) If you need to see details from the CAM (such as provider info or smart card status), you can use the `gnutv` utility: ```sh gnutv -adapter N -cammenu ``` Where N is the DVB-CI adapter number. This opens the CAM menu and shows available information directly from the module. ## Delay before descrambling [Section titled “Delay before descrambling”](#delay-before-descrambling) Some CAMs require extra time before they are ready to descramble channels. If you see channels not opening immediately, you may need to increase the CA Delay option in adapter settings. ## CAM not detected [Section titled “CAM not detected”](#cam-not-detected) If Astra does not show log messages about the CAM at startup, check: * The CAM is firmly inserted into the CI slot * The smart card is correctly placed in the CAM * The driver for your DVB adapter is properly installed ## Related pages [Section titled “Related pages”](#related-pages) * [External DVB-CI](../../../adapters/external-ci/) * [Internal DVB-CI](../../../adapters/internal-ci/) # DVB-T/T2 Reception Issues Some DVB adapters cannot automatically detect the Bandwidth value for DVB-T/T2 signals. In such cases, you need to set this parameter manually in the DVB Adapter settings on the **Advanced** tab. ## Bandwidth Settings [Section titled “Bandwidth Settings”](#bandwidth-settings) For DVB-T and DVB-T2 reception, the Bandwidth parameter determines the channel width. Common values are: * **8 MHz** - used in most European countries * **7 MHz** - used in some countries like Australia * **6 MHz** - used in Americas and some Asian countries Check the broadcast specifications for your region to determine the correct value. ## cxd2878: SLtoAIT\_BandSetting error [Section titled “cxd2878: SLtoAIT\_BandSetting error”](#cxd2878-sltoait_bandsetting-error) This error may appear in the dmesg log for DVB adapters TBS 6209SE. To resolve this issue set the Bandwidth parameter in the DVB Adapter settings, on the **Advanced** tab: * 8 MHz for DVB-T or DVB-T2 * 6 MHz for ISDB-T # No Signal on DVB Adapters > Signal loss on DVB adapters can be caused by weather conditions, physical cable problems, software configuration issues, or hardware failures. This article covers the most common causes and how to diagnose them. Signal loss on DVB adapters can be caused by weather conditions, physical cable problems, software configuration issues, or hardware failures. This article covers the most common causes and how to diagnose them. ## Weather conditions [Section titled “Weather conditions”](#weather-conditions) Weather has the strongest impact on satellite signal quality. Even a perfectly aligned antenna can lose signal completely during severe weather. * **Heavy rain or snow**: signal may drop to zero during intense precipitation. This is known as rain fade and affects higher frequencies (Ku-band) more than lower ones (C-band). * **Snow on the dish**: even a thin layer of snow on the dish surface causes significant signal loss. Keep the dish clear of snow accumulation. * **Strong wind**: can physically move the antenna, causing misalignment. Check antenna position after storms. ### Solar interference [Section titled “Solar interference”](#solar-interference) Twice a year, in spring and autumn, the antenna, satellite, and sun align in a straight line. During these periods, the sun’s radiation overwhelms the satellite signal and causes a short outage. Read more: [Solar Interference on Satellite Reception](../solar-interference/) ## Driver issues [Section titled “Driver issues”](#driver-issues) After a kernel update or server reboot, DVB drivers may stop working. To check if adapters are available, open the adapter settings in the Astra web interface and look at the adapter dropdown list. If the list is empty, the system does not detect any adapters. Read more: [DVB Driver Issues](..) ## failed to open frontend: Device or resource busy [Section titled “failed to open frontend: Device or resource busy”](#failed-to-open-frontend-device-or-resource-busy) Adapter is taken by another process. Maybe Astra started twice. You may check which process uses Astra with next command: ```sh lsof | grep adapter0 ``` Example output: ```plaintext astra 23068 ... /dev/dvb/adapter31/dvr0 astra 23068 ... /dev/dvb/adapter31/frontend0 ``` * `astra` - process name * `23068` - process PID * `/dev/dvb/adapter32/...` - path to the adapter ## Adapter numbers changed after reboot [Section titled “Adapter numbers changed after reboot”](#adapter-numbers-changed-after-reboot) When a server has different adapter models installed, their order may change after a reboot. For example, an LNB receiving from satellite 13E was on `/dev/dvb/adapter0`, but after reboot it became `/dev/dvb/adapter8`. To check if this is the issue: 1. Temporarily disable non-working adapters in Astra 2. Try changing adapter numbers in their settings to match the new order 3. Enable adapters one by one and verify signal reception ## 5G interference with C-band [Section titled “5G interference with C-band”](#5g-interference-with-c-band) In some countries, part of the C-band (3.4–4.2 GHz) has been reallocated for 5G mobile networks. This can cause interference with satellite systems that still use the lower C-band frequencies (3.7–4.2 GHz). If you experience signal degradation on C-band after 5G towers appear nearby, consider installing a 5G filter on your LNB to block terrestrial interference. ## Cable and connector issues [Section titled “Cable and connector issues”](#cable-and-connector-issues) Physical cable problems are a common cause of signal loss: * **Damaged cable**: cuts, kinks, or crushed sections in the coaxial cable * **Water ingress**: moisture inside the cable or connectors, often from poor weatherproofing at outdoor connections * **Short circuit**: the cable shield touching the center conductor, usually at poorly made F-connectors * **Loose connectors**: corroded or improperly tightened F-connectors at the LNB or receiver * **Cable too long**: excessive cable length without proper amplification causes signal attenuation To diagnose cable issues, use a satellite signal meter: 1. First, connect the meter to the cable near the server. If no signal, the problem is in the cable run 2. Then connect the meter directly at the dish. If signal is present here but not at the server end, the cable or connectors between these points are faulty # Solar Interference > Solar interference is a short and predictable signal loss that happens when the sun lines up behind a satellite and raises the noise level at the dish. Solar interference is a temporary loss of satellite signal that happens when the sun lines up behind the satellite from the dish point of view. It is a natural event. It does not mean that Astra, the adapter, or the LNB has failed. ## How it manifests [Section titled “How it manifests”](#how-it-manifests) During a solar interference event, the receiver may briefly lose lock on the transponder. Typical signs are: * **Signal quality drops sharply**: SNR falls and the receiver may report no lock * **BER and UNC errors grow**: the signal becomes too noisy for stable reception * **Video and audio break up**: channels may freeze, pixelate, or disappear for a short time * **Stream errors appear downstream**: PES or CC errors can follow if the DVB signal is already damaged These symptoms usually begin and end quickly. The issue often repeats at about the same local time for several consecutive days. ## Why signal is lost [Section titled “Why signal is lost”](#why-signal-is-lost) Satellite signals that reach the dish are weak. When the sun moves directly behind the satellite, the dish receives strong broadband radio noise from the sun along the same path. This extra noise raises the noise floor at the LNB and tuner input. The receiver can no longer separate the satellite carrier from the background noise well enough, so signal quality drops and errors increase. This is why the problem looks like a sudden reception failure even when the dish alignment and hardware are correct. ## When it happens [Section titled “When it happens”](#when-it-happens) Solar interference usually happens twice a year, around the spring and autumn equinoxes. In practice, operators often see it within about three weeks of March 21 and September 21. The exact dates depend on: * **Your receive location** * **The satellite orbital position** * **The dish pointing direction** For a specific dish and satellite, the event usually lasts for several days in a row. Each daily outage is short, often about 10 to 15 minutes, and happens near the same time each day. ## What to do [Section titled “What to do”](#what-to-do) Solar interference cannot be prevented by software settings. During the event: 1. Check whether the signal loss matches the expected pattern: short duration, same time of day, several consecutive days. 2. Wait for the alignment window to pass. Reception usually returns to normal on its own. 3. Avoid unnecessary dish realignment during the outage. The issue is caused by the sun, not by a moved antenna. 4. If the signal does not recover after the expected window, check other causes such as weather, cable faults, or hardware problems. ## How to distinguish it from other problems [Section titled “How to distinguish it from other problems”](#how-to-distinguish-it-from-other-problems) * **Rain fade**: happens during heavy rain or snow, not at the same time on clear days. Read more: [No Signal on DVB Adapters](../no-signal/) * **Dish misalignment**: does not usually recover after 10 to 15 minutes by itself and is often related to wind or physical movement. Read more: [No Signal on DVB Adapters](../no-signal/) * **Cable or connector faults**: tend to be random or permanent until the damaged part is repaired. Read more: [No Signal on DVB Adapters](../no-signal/) * **5G interference on C-band**: depends on local terrestrial interference, not on seasonal sun transit. Read more: [No Signal on DVB Adapters](../no-signal/) * **Persistent BER or UNC errors**: if errors continue outside the expected window, check signal path and dish condition. Read more: [BER/UNC Error on DVB Adapters](../ber-unc-error/) ## Related pages [Section titled “Related pages”](#related-pages) * [DVB Adapter options for DVB-S/S2](../../../adapters/s/) * [No Signal on DVB Adapters](../no-signal/) * [BER/UNC Error on DVB Adapters](../ber-unc-error/) # Common Issues with HTTP/HLS Input ## Common HTTP codes [Section titled “Common HTTP codes”](#common-http-codes) HTTP response codes are three-digit numerical indicators given by a server in reply to a client’s HTTP request. On successful request, the server returns code 200 and the associated response content, such as a media stream or HLS media playlist. ### 404 Not Found [Section titled “404 Not Found”](#404-not-found) This status code signifies that the server cannot locate any match for the requested URL. Possible causes: * incomplete URL address or typographical error * temporary link to the channel has expired and is no longer available * channel has been disabled on the server * server is unable to retransmit the channel due to reception errors ### 403 Forbidden [Section titled “403 Forbidden”](#403-forbidden) Indicates that the client’s request was understood by the server, but the server is refusing to complete it. Possible causes: * temporary token has expired or has not been provided * access to the channel is restricted based on IP address (GEO location) or User-Agent header * access has been revoked by the server administrator ### Connection timeout [Section titled “Connection timeout”](#connection-timeout) Typically occurs when a client’s request to a server takes too long time. Possible causes: * network issues * overloaded servers or a configured connection limit * server-side restriction on the allowed connection duration * firewall restrictions on the connection * incorrect port number or server address ## Why is the stream quality lower after retransmission? [Section titled “Why is the stream quality lower after retransmission?”](#why-is-the-stream-quality-lower-after-retransmission) When working with HLS reception, it’s possible to encounter quality issues after retransmitting a stream. For instance, a stream may play in HD quality in VLC player, but after retransmission, the video appears in low resolution. This problem typically arises because the HLS stream contains variants with different resolutions. To resolve this issue, download HLS playlist and open in a text editor: The playlist will have content that looks like this: ```plaintext #EXTM3U #EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=6221600,RESOLUTION=1920x1080 https://example.com/video/1080.m3u8 #EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=246440,RESOLUTION=320x184 https://example.com/video/240.m3u8 ``` Examine the playlist content and look for the `#EXT-X-STREAM-INF` lines that define the different quality streams available. In this example, two streams are available: one with a resolution of 1920x1080 and another with a resolution of 320x184. Select the URL corresponding to the desired quality. In the example playlist, the HD stream URL is `https://example.com/video/1080.m3u8` Use this URL in the Input settings # Common Issues with HTTP/HLS Output > Common issues and solutions for HTTP delivery in Astra ## Error 404 [Section titled “Error 404”](#error-404) A 404 error means the requested resource could not be found. Common causes and how to fix them: 1. **Channel is disabled**: Check that the channel is enabled in the Astra web interface 2. **Wrong port in URL**: Astra serves HTTP streams on different ports: * If HTTP Play is used, the port may match the web interface or set manually in Settings → HTTP Play. Ensure the port in the URL matches the one configured in Astra. * The port is specified in the HTTP Output URL. Ensure the port in the URL matches the one configured in the HTTP Output. 3. **Port conflict**: Another application is using the same port ### Checking for Port Conflicts [Section titled “Checking for Port Conflicts”](#checking-for-port-conflicts) To see which application is using a port, run this command: ```sh netstat -tnlp ``` Sometimes the same Astra process listens on multiple interfaces for the same port: ```plaintext tcp 0 0 0.0.0.0:8000 0.0.0.0:* LISTEN 43313/astra tcp 0 0 192.168.88.1:8000 0.0.0.0:* LISTEN 43313/astra ``` This shows one Astra process bound to port 8000 on: * `0.0.0.0:8000` - listens on all network interfaces * `192.168.88.1:8000` - listens on a specific interface To fix port conflicts: * Use the same interface for all HTTP outputs in the channel * Use different ports for different interfaces ## Channel Delay on Start [Section titled “Channel Delay on Start”](#channel-delay-on-start) When starting a channel, there is a long delay before playback begins. The delay may be caused by the Authorization method configured in Astra. When using the HTTP Backend authorization, Astra sends an HTTP request to an external middleware for each playback request. If the middleware is slow to respond, playback is delayed. To verify if this is the case, you may temporarily disable authorization. We recommend using HTTP Backend authorization only with fast, reliable middleware (response time under 100ms). # Subscription Expired Astra requires an active license to work. When your subscription expires, Astra will stop all channels after some time. ## Renew Subscription [Section titled “Renew Subscription”](#renew-subscription) If your license expired recently (less than 10 days ago), you can renew it: 1. Go to your profile: 2. Click **Renew subscription** for your license 3. Choose your payment method ## Buy New License [Section titled “Buy New License”](#buy-new-license) After 10 days from expiration, the license is permanently blocked and cannot be renewed. You need to buy a new license: 1. Go to the purchase page: 2. Select the license you need 3. Choose your payment method ## License Shows as Expired After Renewal [Section titled “License Shows as Expired After Renewal”](#license-shows-as-expired-after-renewal) If you renewed your license but Astra still shows “License expired!” in the web interface. First, check that your license was renewed successfully: 1. Go to your [profile](https://cesbo.com/profile) 2. Verify that the subscription end date has been extended If the subscription end date hasn’t changed, contact support. If you paid by bank transfer, send your payment confirmation. Next, verify the License ID in Astra matches your profile: 1. In the web interface, go to **Settings** → **License** 2. Check the **License ID** displayed 3. Compare it with the License ID in your [profile](https://cesbo.com/profile) If the License IDs don’t match, you may have renewed a different license or purchased a new one. Contact support for assistance. If the License IDs match, restart Astra to apply the updated license information: 1. In the web interface, go to **Settings** 2. Click **Restart** Alternatively, use the command line: ```bash systemctl restart astra ``` After restart, your renewed license will be active. # Failed to Check License Astra checks your license on startup by connecting to one of these servers: * `ls1.cesbo.com` * `ls2.cesbo.com` * `ls3.cesbo.com` ## Steps [Section titled “Steps”](#steps) 1. Check that your server has internet access 2. Make sure these domains are not blocked by your firewall 3. Verify that outbound HTTP and HTTPS connections are allowed # PayPal Payment Not Available If you want to pay with PayPal but the payment system doesn’t show this option, you need to change the currency.  ## Supported Currencies for PayPal [Section titled “Supported Currencies for PayPal”](#supported-currencies-for-paypal) We use PayPal via Stripe payments, it works with next currencies: EUR, GBP, USD, CHF, CZK, DKK, NOK, PLN, SEK, AUD, CAD, HKD, NZD, SGD ## How to Enable PayPal Payment [Section titled “How to Enable PayPal Payment”](#how-to-enable-paypal-payment) 1. On the payment page, find the currency selector 2. Switch from your local currency (like PEN) to one of the supported currencies above 3. After changing the currency, PayPal will appear as a payment option The price will be automatically converted to the selected currency. # CC Error CC (Continuity Counter) errors indicates that MPEG-TS packets continuity is corrupted. Error can be caused by MPEG-TS packets loss or excess. ## CC Error in Logs [Section titled “CC Error in Logs”](#cc-error-in-logs) This message printed as debug message in Astra logs, and as error message in the Astra MPEG-TS Analyzer logs. ```plaintext Jan 27 09:00:00: INFO: Bitrate: 13259 Kbit/s Jan 27 09:00:00: ERROR: CC: PID:18=3 PID:20=3 PID:256=24 Jan 27 09:00:01: INFO: Bitrate: 13261 Kbit/s Jan 27 09:00:01: ERROR: CC: PID:18=5 PID:20=2 ``` ## CC Error on UDP Receiving [Section titled “CC Error on UDP Receiving”](#cc-error-on-udp-receiving) UDP does not guarantee data delivery, so packets can be lost, duplicated, or arrive out of order. There is two common issues: packets loss or packets excess. Check [CC Errors on receiving UDP](../../udp/input/#cc-errors-on-receiving-udp). ## CC Error on DVB Receiving [Section titled “CC Error on DVB Receiving”](#cc-error-on-dvb-receiving) DVB depends of the signal quality. Check errors on DVB adapter: [BER and UNC Errors](../../dvb/ber-unc-error/). If the issue appears at the same time of day for several days, also check [Solar Interference on Satellite Reception](../../dvb/solar-interference/) # Channel has no active inputs The error occurs if the channel does not have any available sources for switching. In the channel settings (Single program stream), you can specify multiple sources (Input) for reservation. These sources work in a sequential order - if the first source fails, a switch to the second source, and so on. The error occurs if the channel lacks available sources for switching. # PES Error PES (Packetized Elementary Stream) error indicates that the header of the packets with media data such as video or audio is corrupted. This can lead to issues in decoding and playback of the stream. ## PES Error in Logs [Section titled “PES Error in Logs”](#pes-error-in-logs) ```plaintext Jan 27 09:00:00: INFO: Bitrate: 13259 Kbit/s Jan 27 09:00:00: ERROR: PES: PID:101=4 PID:102=6 Jan 27 09:00:01: INFO: Bitrate: 13261 Kbit/s Jan 27 09:00:01: ERROR: PES: PID:101=5 PID:102=5 ``` ## Common Causes of PES Errors [Section titled “Common Causes of PES Errors”](#common-causes-of-pes-errors) * Issue with a descrambling of the protected stream, such as invalid key, expired subscription, conditional access module overheat * DVB signal issue due to [solar interference](../../dvb/solar-interference/) # CPU Power Mode In the world of digital TV streaming, every millisecond matters. Delays or lags can significantly impact the quality of service. One of the key factors is the CPU power mode. By default, Linux servers have their CPUs set to a power-saving mode to reduce power consumption and manage heat generation. To ensure optimal performance of your streaming software, it is recommended to set your CPU to its maximum performance mode. Note You can use our Tune script to automatically configure these settings. [Read more](../../../quick-start/tune/) ## With cpupower utility [Section titled “With cpupower utility”](#with-cpupower-utility) To check the CPU power mode on a Linux server, you can use the `cpupower` utility. This utility is part of the `linux-tools-common` package. ### Install cpupower [Section titled “Install cpupower”](#install-cpupower) ```plaintext sudo apt-get update sudo apt-get install linux-tools-common ``` ### Check current settings [Section titled “Check current settings”](#check-current-settings) ```plaintext cpupower frequency-info ``` This command will display the current CPU frequency, governor and other information. If the governor is set to ‘powersave’ or ‘ondemand’, then the CPU is in power saving mode. ### Disable the power saving mode [Section titled “Disable the power saving mode”](#disable-the-power-saving-mode) If you want to disable the power saving mode, you can set the governor to `performance`. This will make the CPU run at maximum frequency. ```plaintext cpupower frequency-set -g performance ``` This setting will be lost after a reboot. If you want to make it permanent, you can add the above command to `/etc/rc.local` file so that it gets executed at every boot. ## Check CPU mode manually [Section titled “Check CPU mode manually”](#check-cpu-mode-manually) ```plaintext cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor ``` This command will display the current CPU governor for each core. Information about current CPU frequency available in the `/proc/cpuinfo` file: ```plaintext processor : 0 model name : Intel(R) Xeon(R) CPU E5-2650 v2 @ 2.60GHz cpu MHz : 1197.109 ``` as we can see current CPU frequency is only 1.2GHz. # PCIe Bus Error PCIe devices may stop working over time or work with intermittent issues. For example, DVB adapters may show CC errors and signal re-tuning, while Ethernet adapters may lose link or drop packets. These malfunction signs can be reflected as the following error in the dmesg: ```plaintext pcieport 0000:00:1c.3: PCIe Bus Error: severity=Corrected, type=Physical Laye ``` Typically, this error occurs as a result of the system’s Active-State Power Management (ASPM) attempting to reduce power supply to the PCIe port. ## Disable ASPM [Section titled “Disable ASPM”](#disable-aspm) On the servers we recommend to disable power management. Open file `/etc/default/grub` in any text editor and find the line started with: ```plaintext GRUB_CMDLINE_LINUX_DEFAULT= ``` add the parameter `pcie_aspm=off`: ```plaintext GRUB_CMDLINE_LINUX_DEFAULT="quiet splash pcie_aspm=off" ``` Save the file and apply the changes: ```plaintext sudo update-grub ``` Restart your server. # Read-only file system The error name says it all: a program cannot write to the disk because the disk is in “read-only” mode, or the program is running with restricted write permissions. ## How This Error Shows Up in Astra [Section titled “How This Error Shows Up in Astra”](#how-this-error-shows-up-in-astra) The most common scenarios where this error occurs: * When Astra starts for the first time and tries to save the initial configuration * When saving changes in the web interface In the log, you will see an error like this: ```plaintext failed to save config /etc/astra/astra.conf [Read-only file system] ``` ## Filesystem Intentionally Mounted as Read-Only [Section titled “Filesystem Intentionally Mounted as Read-Only”](#filesystem-intentionally-mounted-as-read-only) In some cases, the filesystem may be deliberately mounted in read-only mode. This can happen with live USB systems, recovery modes, or certain embedded systems. ### How to Check [Section titled “How to Check”](#how-to-check) You can check if a filesystem is mounted as read-only by running: ```sh mount | grep ' / ' ``` Look for the `ro` (read-only) option in the output. Example: ```plaintext /dev/sda1 on / type ext4 (ro,relatime) ``` If you see `ro` in the options, the filesystem is read-only. You can also check with: ```sh cat /proc/mounts | grep ' / ' ``` ### How to Fix [Section titled “How to Fix”](#how-to-fix) To remount the root filesystem as read-write: ```sh mount -o remount,rw / ``` This change may not persist after reboot. To make it permanent, check your `/etc/fstab` file and ensure the root filesystem is not set to mount as read-only. The fourth field in `/etc/fstab` should not contain `ro`. ## Automatic Read-Only Filesystem Transition [Section titled “Automatic Read-Only Filesystem Transition”](#automatic-read-only-filesystem-transition) Linux filesystems can automatically switch to read-only mode when critical errors are detected. This is a protection mechanism to prevent data corruption. ### Causes of Automatic Transition [Section titled “Causes of Automatic Transition”](#causes-of-automatic-transition) The most common causes include: * **Disk errors**: Physical problems with the disk, such as bad sectors or hardware failure * **Filesystem corruption**: Errors in the filesystem structure detected during operation * **I/O errors**: Problems communicating with the storage device * **RAID degradation**: When a RAID array enters a degraded state ### How to Check [Section titled “How to Check”](#how-to-check-1) Check the system logs for disk or filesystem errors: ```sh dmesg | grep -i "read-only" ``` Or: ```sh journalctl -xe | grep -i "read-only" ``` Look for messages about I/O errors, filesystem errors, or remounting: ```plaintext EXT4-fs error: remounting filesystem read-only I/O error, dev sda, sector 12345 ``` You can also check SMART data for the disk: ```sh smartctl -a /dev/sda ``` Look for reallocated sectors, pending sectors, or other indicators of disk failure. ## Mount Namespace Isolation [Section titled “Mount Namespace Isolation”](#mount-namespace-isolation) A process may be running in an environment where the filesystem has been deliberately restricted using mount namespaces. This is common in containerized environments or with certain security frameworks. If you encounter this situation and you know what mount namespaces are, you already know how to handle it. ## systemd ProtectSystem Parameter [Section titled “systemd ProtectSystem Parameter”](#systemd-protectsystem-parameter) The `ProtectSystem` parameter in systemd service files can restrict write access to certain directories. ### About ProtectSystem [Section titled “About ProtectSystem”](#about-protectsystem) The `ProtectSystem` option makes parts of the filesystem read-only for the service: * `ProtectSystem=strict` - Makes the entire filesystem read-only except for `/proc`, `/dev`, and `/sys` * `ProtectSystem=full` - Makes `/usr`, `/boot`, and `/efi` read-only * `ProtectSystem=yes` - Makes `/usr` and `/boot` read-only Astra itself (when initialized with `astra init`) does not use this parameter in its service file. However, if Astra is launched through another process monitoring service, such as `monit`, the service file for that monitoring tool may include `ProtectSystem`. ### How to Fix [Section titled “How to Fix”](#how-to-fix-1) Check the systemd service file that starts Astra or the monitoring service: ```sh systemctl cat astra ``` Or if Astra is started by another service like monit: ```sh systemctl cat monit ``` Look for `ProtectSystem` in the `[Service]` section. If present, remove it or set it to `false`: ```ini [Service] ProtectSystem=false ``` After editing the service file, reload systemd and restart the service: ```sh systemctl daemon-reload systemctl restart astra ``` # Too many open files Every process in Linux runs with limits. One of these limits is the number of files and network sockets a process can open at the same time. When the limit is too low, you may see the error **Too many open files**. ## Astra and Open File Limits [Section titled “Astra and Open File Limits”](#astra-and-open-file-limits) In Astra, this error may appear when the system limit is not set high enough. By default, if you installed Astra with the command `astra init` (as described in our Quick Start guide), the limit is set to **65536** open files. This value is usually enough for most use cases. If you start Astra in a different way, you need to make sure the open file limit is set correctly. Below are the common cases. ## Starting with init.d [Section titled “Starting with init.d”](#starting-with-initd) When using an init.d script, you must increase the limit before starting Astra. Add the `ulimit -n 65536` line before the command that launches Astra. Example script: ```sh if [ "$1" = "start" ]; then /usr/bin/astra -c /etc/astra/astra.conf -p 8000 --pid /var/run/astra.pid --log /var/log/astra.log --daemon elif [ "$1" = "stop" ]; then if [ -f /var/run/astra.pid ]; then kill $(cat /var/run/astra.pid) fi elif [ "$1" = "restart" ]; then $0 stop sleep 1 $0 start fi ``` ## Starting with systemd [Section titled “Starting with systemd”](#starting-with-systemd) For systemd services, you should set the limit inside the service file. In the `[Service]` section, add: ```ini [Service] Type=simple LimitNOFILE=65536 ExecStart=/usr/bin/astra -c /etc/astra/astra.conf -p 8000 --log /var/log/astra.log --no-stdout ``` This ensures Astra can open enough files and sockets without hitting the error. ## Checking the Current Limit [Section titled “Checking the Current Limit”](#checking-the-current-limit) You can check the current open file limit for a running process using the ulimit or cat commands. If you are inside the same shell where Astra is running, run: ```sh ulimit -n ``` This shows the maximum number of open files for that shell (and any processes started from it). If Astra is already running as a daemon, find its process ID (PID) and check directly: ```sh pidof astra ``` This returns the PID of the Astra process. Then run: ```sh cat /proc//limits | grep "open files" ``` Example output: ```plaintext Max open files 65536 65536 files ``` # Configure IGMP Version for UDP IGMP (Internet Group Management Protocol) is a communication protocol used by devices on a network to join and leave multicast groups. IGMP has several versions, including IGMPv2 and IGMPv3, which offer different features and improvements. Some network equipment, such as switches or routers, may only support IGMPv2, which can cause issues if your server attempts to join a multicast group using IGMPv3. Therefore, it may be necessary to change the IGMP version used by the server. ## Configuration [Section titled “Configuration”](#configuration) To change IGMP version on your server, you can modify the `/etc/sysctl.conf` file. First, determine the interface that needs to use a different IGMP version (e.g., eth0). Then, add the following line to the `/etc/sysctl.conf` file: ```plaintext net.ipv4.conf.eth0.force_igmp_version=2 ``` This line forces your server to use IGMPv2 on the specified interface. To apply the changes, save file and execute the following command: ```plaintext sudo sysctl -p ``` ## Check IGMP version [Section titled “Check IGMP version”](#check-igmp-version) To confirm that the IGMP version has been changed successfully, you can use the tcpdump command to capture network traffic on the specified interface. For example, to capture IGMP traffic on eth0, execute the following command: ```plaintext sudo tcpdump -i eth1 igmp ``` Then try to subscribe to the multicast stream. For example: ```plaintext astra --analyze udp://eth1@239.255.1.1:1234 ``` This will display any IGMP packets on the interface. Check the output to confirm that the IGMP version being used is now IGMPv2. # Common Issues with UDP Input UDP (User Datagram Protocol) - communication protocol in local networks or Internet, with minimal delays and minimal stability. ## System Tune [Section titled “System Tune”](#system-tune) Before troubleshooting we recommend using our [System Tune](../../../quick-start/tune/) script to optimize your Linux settings. ## Software to analyze your issue [Section titled “Software to analyze your issue”](#software-to-analyze-your-issue) ### Analyze UDP with Astra MPEG-TS Analyzer [Section titled “Analyze UDP with Astra MPEG-TS Analyzer”](#analyze-udp-with-astra-mpeg-ts-analyzer) With Astra you can analyze any supported source. Just launch in console next command: ```sh astra --analyze "udp://eth0@239.255.1.1:1234" ``` To stop Astra analyzer press Ctrl+C. Read more about [Astra MPEG-TS Analyzer](../../../tools/mpeg-ts-analyzer/) ### Analyze UDP with Tcpdump [Section titled “Analyze UDP with Tcpdump”](#analyze-udp-with-tcpdump) Tcpdump is a common tool to check network traffic. For example, command to check UDP multicast receiving to group 239.255.1.1 on the interface eth0: ```sh tcpdump -pnni eth0 udp and host 239.255.1.1 ``` If you don’t know actual interface you may find it with command: ```sh ip route get 239.255.1.1 ``` The tcpdump output looks like many lines with information about packets source, destination, and length. For example: ```plaintext 21:38:42.143839 IP 192.168.88.100.33610 > 239.255.1.1.1234: UDP, length 1316 21:38:42.143868 IP 192.168.88.100.33610 > 239.255.1.1.1234: UDP, length 1316 ``` To stop tcpdump press Ctrl+C ## UDP Not working at all [Section titled “UDP Not working at all”](#udp-not-working-at-all) Not working means a zero bitrate in the Astra MPEG-TS Analyzer output. For example: ```plaintext Jan 27 09:00:00: INFO: Bitrate: 0 Kbit/s Jan 27 09:00:01: INFO: Bitrate: 0 Kbit/s ``` ### No UDP packets on interface [Section titled “No UDP packets on interface”](#no-udp-packets-on-interface) First of all check traffic on the network interface with tcpdump tool. If there is no information about incoming packets, then need to check network configuration or source configuration. 1. Invalid routes configuration. If you have has several interfaces, please, check that route to multicast group configured correctly or define interface name in the udp address 2. Connectivity issues. Check that you server connected to ethernet or vlan interface created 3. Incompatable IGMP Version. For example your server uses IGMPv3, but network equipment supports only IGMPv2: [Configure IGMP Version](../igmp-version/) ### Software unable to receive UDP packets [Section titled “Software unable to receive UDP packets”](#software-unable-to-receive-udp-packets) If tcpdump shows information about UDP packets, there is could be next issues: 1. UDP droped by firewall rulles. Check your firewall configuration 2. If you server has multiplay interfaces then append route to the multicast group or configure RP Filter: [RP Filter and Multicast receiving in Linux](../rp-filter/) ## CC Errors on receiving UDP [Section titled “CC Errors on receiving UDP”](#cc-errors-on-receiving-udp) CC (Continuity Counter) errors indicates that packets continuity is corrupted. Error can be caused by packets loss or excess: ```plaintext Jan 27 09:00:00: INFO: Bitrate: 13259 Kbit/s Jan 27 09:00:00: ERROR: CC: PID:18=3 PID:20=3 PID:256=24 Jan 27 09:00:01: INFO: Bitrate: 13261 Kbit/s Jan 27 09:00:01: ERROR: CC: PID:18=5 PID:20=2 ``` ### Packets loss [Section titled “Packets loss”](#packets-loss) First of all need to check losses and errors on the network interface: ```sh ip -s link show eth0 ``` Look at RX errors. Some network cards provide more detailed information about the nature of the loss: ```sh ethtool -S eth0 ``` Losses can be not only on the network cards of your server. They can also be on the network equipment port. You can find the information how to see it in the documentation of the network equipment manufacturer. Where eth0 is an interface name. After the RX-row will be row with numbers. Third number is an UDP receiving errors. ### QoS configuration [Section titled “QoS configuration”](#qos-configuration) Quality of Service (QoS) settings on your network equipment can affect UDP traffic. Make sure that your QoS settings prioritize UDP traffic and do not limit its bandwidth. ### Packets excess [Section titled “Packets excess”](#packets-excess) Excess packets looks as doubled bitrate in Astra MPEG-TS analyzer. Could be check with `tcpdump` where packets with same destination has different sources: ```plaintext 21:38:42.143839 IP 192.168.88.100.33610 > 239.255.1.1.1234: UDP, length 1316 21:38:42.143868 IP 192.168.88.100.24081 > 239.255.1.1.1234: UDP, length 1316 ``` There is could be two causes: * If source address is same but ports are different (in example is 33610 and 24081) then source server sends same channel twice * If source addresses are different then more than one server sends packets into the same group In both cases need to check remote server configuration. If this is not possible or as temporary solution you can drop packets from second source with firewall. # Configuring Network Buffers for UDP Proper buffer configuration prevents data loss when sending or receiving UDP streams. ## Configure Buffer Sizes [Section titled “Configure Buffer Sizes”](#configure-buffer-sizes) Add the following settings to the `/etc/sysctl.conf` file. For 1G Ethernet Adapters: ```ini net.core.rmem_max = 16777216 net.core.wmem_max = 16777216 net.ipv4.udp_mem = 8388608 12582912 16777216 net.ipv4.tcp_rmem = 4096 87380 8388608 net.ipv4.tcp_wmem = 4096 65536 8388608 net.core.wmem_default = 16777216 net.core.rmem_default = 16777216 net.ipv4.tcp_tw_reuse = 1 ``` For 10G Ethernet Adapters: ```ini net.core.rmem_max = 67108864 net.core.wmem_max = 67108864 net.ipv4.udp_mem = 8388608 16777216 33554432 net.ipv4.tcp_rmem = 4096 87380 33554432 net.ipv4.tcp_wmem = 4096 65536 33554432 net.core.wmem_default = 33554432 net.core.rmem_default = 33554432 net.core.default_qdisc=fq net.ipv4.tcp_congestion_control=bbr net.ipv4.tcp_tw_reuse = 1 ``` For 40G Ethernet Adapters: ```ini net.core.rmem_max = 134217728 net.core.wmem_max = 134217728 net.ipv4.udp_mem = 8388608 33554432 67108864 net.ipv4.tcp_rmem = 4096 87380 67108864 net.ipv4.tcp_wmem = 4096 65536 67108864 net.core.wmem_default = 67108864 net.core.rmem_default = 67108864 net.core.default_qdisc=fq net.ipv4.tcp_congestion_control=bbr net.ipv4.tcp_tw_reuse = 1 ``` To apply settings without restarting, run: ```bash sysctl -p ``` Verify current buffer values: ```bash sysctl \ net.core.rmem_default \ net.core.rmem_max \ net.core.wmem_default \ net.core.wmem_max \ net.ipv4.udp_mem \ net.ipv4.tcp_wmem ``` ## Network Card Buffers [Section titled “Network Card Buffers”](#network-card-buffers) On high-load servers, configure the network card buffer to prevent packet loss. Check current buffer settings: ```bash ethtool -g eth1 ``` Example output: ```plaintext Ring parameters for eth1: Pre-set maximums: RX: 4096 RX Mini: 0 RX Jumbo: 0 TX: 4096 Current hardware settings: RX: 4096 RX Mini: 0 RX Jumbo: 0 TX: 256 ``` The optimal buffer size depends on your hardware. For high-frequency multi-core processors (over 3 GHz), maximum values often work best. For other systems, an average value is a good starting point. To increase the buffer size: ```bash ethtool -G eth1 rx 2048 ``` ## Related Articles [Section titled “Related Articles”](#related-articles) * [System Tune](../../../quick-start/tune/) - script to optimize Linux settings for streaming # RP Filter for UDP The rp\_filter technology is a useful tool for enhancing the security and protection of servers that receive UDP multicast traffic, particularly for servers with multiple network interfaces. When configuring servers to receive UDP multicast traffic, there are two options available: configuring system routing for multicast groups or modifying the rp\_filter setting. ## Configure strict mode for RP filter [Section titled “Configure strict mode for RP filter”](#configure-strict-mode-for-rp-filter) To modify the rp\_filter setting, add the following lines to the `/etc/sysctl.conf` file: ```plaintext net.ipv4.conf.eth0.rp_filter = 2 ``` Note that `eth0` should be replaced with the name of the interface being used. To apply the changes, either restart the system or execute the following command: ```plaintext sysctl -p ``` ## RP Filter values [Section titled “RP Filter values”](#rp-filter-values) There are three possible values for the rp\_filter parameter in Linux: * `0` - disables the rp\_filter feature altogether * `1` - default setting and enables strict reverse path filtering. In this mode, the kernel checks whether incoming packets arrive on the expected interface according to the routing table, and drops packets that do not * `2` - this setting enables loose reverse path filtering. This mode is less strict than strict reverse path filtering and allows packets to arrive on other interfaces, provided that they can be routed back to the source address on the interface from which they were received The choice of rp\_filter setting depends on the specific network configuration and security requirements of the system. It is important to select the appropriate setting to ensure optimal security and performance of the network. ## Related Articles [Section titled “Related Articles”](#related-articles) * [System Tune](../../../quick-start/tune/) - script to optimize Linux settings for streaming # Connection Closed in Astra Web Interface If you see a **Connection Closed** message in the Astra web interface, it may indicate that the server is not running or there is a network issue preventing the interface from connecting to the server.  ## Connection to Server [Section titled “Connection to Server”](#connection-to-server) Ensure that the server is running and accessible - connect to it via SSH. ## License Issue [Section titled “License Issue”](#license-issue) For versions released before 2025-11-11, a **Connection Closed** message may also indicate a license issue. Check the Astra logs for any license-related errors and ensure that your license is valid and properly installed. Next command shows when the Astra server was last started and why it might have stopped: ```plaintext tac /var/log/astra.log | grep -m1 -A5 Starting ``` Also you can check your license by running Astra in console: ```plaintext astra -c /tmp/test.conf ``` If there are any license issues, they will be displayed in the console output. # Reset Password to Astra Web Interface You can reset the Astra interface password using the server console command: ```plaintext astra --reset-password ``` The command will ask you to enter the following information: * **Port**: the port number for your web interface (default is 8000) * **User login**: the username for the account * **New password**: the new password to set ## Change user password [Section titled “Change user password”](#change-user-password) An administrator can change any user’s password through the web interface: 1. Open **Settings** → **Users** 2. Select the user whose password you want to change 3. Enter the new password and click **Apply** If you’ve changed your own password, the Astra web interface will be reloaded and you will be required to log in with your new password. # Uninstall If Astra is not needed anymore you can remove it completely from your server. Danger Before uninstall please [Make a Backup](../../quick-start/backup/)! ## Disable service [Section titled “Disable service”](#disable-service) Stop service and turn autorun off: ```sh systemctl stop astra systemctl disable astra ``` ## Remove service [Section titled “Remove service”](#remove-service) Remove service from system: ```sh astra remove ``` If you have several services on your server, then custom name should be specified: ```sh astra remove astra-8001 ``` ## Cleanup [Section titled “Cleanup”](#cleanup) Finally remove binary file and configuration files: ```sh rm -rf /usr/bin/astra /etc/astra ``` # Cable Television with Astra for Hospitality Industry  Hospitality TV, offering an excellent TV solution with high-quality broadcasts and a selection of the best channels, is an essential part of hotel service. The number and quality of channels create a positive impression on guests. However, this is where the challenge arises. Hotels need to either modernize their existing TV network or design a new one, finding a balance between equipment costs and required services. We suggest considering the Astra software, which boasts powerful and flexible features when used in conjunction with a DVB-C modulator. In this article, we will explore the pros and cons of such a solution and walk through the steps to set it up. ## Advantages of cable television [Section titled “Advantages of cable television”](#advantages-of-cable-television) * built on a regular TV cable, you can use the existing hotel network * a large number of channels with no quality restrictions * any TV set is capable of receiving cable TV. You don’t need any additional hardware in the guests rooms * network reliability * broadcasting control such as monitoring, configuration, channel switching, etc. All this is possible with Astra Web Interface * last but not least, you can simply expand the number of video sources and channels. Astra allows you to receive an input signal not only from DVB cards, but also from a network (HTTP, HLS, UDP, RTSP), as well as create your TV channels from your video recordings. ## Disadvantages [Section titled “Disadvantages”](#disadvantages) * the cost of the headend, including DVB-C modulator and DVB cards for receiving * some old TV sets may not support DVB-C standard for cable TV ## Hardware [Section titled “Hardware”](#hardware)  This simple diagram is used for the illustration. We have a Satellite signal, Linux-based Server PC with DVB-S/S2 card(s), and RESI DVB-C FSM Modulator card(s). ### DVB-S/S2 Receiver [Section titled “DVB-S/S2 Receiver”](#dvb-ss2-receiver) For receiving satellite channels you may use any DVB-S/S2 adapter with drivers for Linux.  Most popular DVB receivers are: * [Digital Devices MAX SX8 Pro](https://www.digital-devices.eu/shop/en/tv-cards/all-tv-cards/340/digital-devices-max-sx8-pro-4/8-8-tuner-tv-card-dvb-s2/dvb-s2x-full-spectrum) * [Digital Devices Max M4](https://www.digital-devices.eu/shop/en/tv-cards/all-tv-cards/341/digital-devices-max-m4-4x-multi-band-tuner-tv-card?c=167) - all-rounder for satellite, cable or terrestrial reception * [TBS6909-X](https://www.tbsdtv.com/products/tbs6909-x-dvb-s-s2-s2x-octa-tuner-pcie-card.html) ### DVB-C Modulator [Section titled “DVB-C Modulator”](#dvb-c-modulator) In this article, we consider simple steps on How to set up Astra for DVB-C Modulation using [RESI DVB-C FSM 8](https://www.digital-devices.eu/shop/en/business-tv/qam-sdr-modulator/). Also you may use [TBS6004](https://www.tbsdtv.com/products/tbs6004-dvb-c-4-qam-pcie-card.html) modulator.  Short description: * RESI DVB-C FSM 8 has 8 transponders according to DVB-C specification * Frequency range: 114 - 858 MHz * Symbol rates: 1.0 - 7.1 MSym/s * QAM: 16, 32, 64, 128, 256 * Signal / Noise ratio: 42dB * Output with 8 active transponder: 101 dBµV * The FSM8 can make up to 7.1 MSym/s and QAM256. The maximum delivered bitrate is about 52Mbps Note We advise sending no more than 40-42Mbps to a single transponder, especially if the input stream is from the satellite. As sat-channels usually have floating bitrate, which, for example, at HD channel may jump from 6Mbps to 11Mbps. According to that, we may calculate how many channels we may put on a single transponder and on all available transponders: * 4 x HD channels \~7Mbps = 28Mbps * 4 x SD channels \~3Mbps = 12Mbps Approximately we can get 8 channels at one transponder, multiplied by 8 transponders we can get up to 64 channels in your DVB-C network. This is combination of channels may be different, it is up to your needs. If you need more channels you may get RESI DVB-C FSM 16 or 24. ## Requirements [Section titled “Requirements”](#requirements) ### Hardware [Section titled “Hardware”](#hardware-1) * Server PC, at least Quad Core Intel® or AMD® CPU 2.8GHz, 8Gb RAM, with 2 or more PCIe slots, depending on the quantity of PCIe cards * DVB-C Modulators (RESI or TBS) * DVB-S/S2 or DVB-T/T2 TV Cards (as an example) ### Software [Section titled “Software”](#software) * Linux-based operation system. We recommend Ubuntu 22.04 LTS * Cesbo Astra * DVB Card drivers * Internet Browser on your PC. Chrome, Safari, or Firefox ## Configure Astra [Section titled “Configure Astra”](#configure-astra) ### Install Astra [Section titled “Install Astra”](#install-astra) First of all, we need to prepare our server machine and install Linux and Astra. Information about Ubuntu installation could be found on the [official web site](https://ubuntu.com/tutorials/install-ubuntu-server) Astra installation is simple – just copy a single binary file to your server. Here, in detail, you may find how to [Install Astra](../../quick-start/) Quite often customers forget to configure their Adapters before the next steps. So be sure that you have DVB card drivers installed on the server. * [DigitalDevices Driver Installation](../../adapters/dd-driver/) * [TBS Driver Installation](../../adapters/tbs-driver/) * For other adapters you may find information on the vender web site ### Receiving channels with Astra [Section titled “Receiving channels with Astra”](#receiving-channels-with-astra) Now is the time to configure all our Adapters and find channels, which we want to Modulate over DVB-C. To configure receiving channels from satellite we recommend to having a look at these articles: * [Introduction to DVB Adapter Tuning](../../adapters/) * [DVB-S/S2 Tuner Options](../../adapters/s/) * [Scan DVB Adapter](../../adapters/scan/) Below provided screenshot of example adapter settings:  ### Scan and select the required channels [Section titled “Scan and select the required channels”](#scan-and-select-the-required-channels) When we figured out how to configure our Adapters, we may make a scan of the required Transponder (frequency) and append channels to Astra by selecting all the programs you want to add.   ### Create New Stream with MPTS [Section titled “Create New Stream with MPTS”](#create-new-stream-with-mpts) MPTS is a Multi Program Transport Stream (or multiplex) is a stream containing several services (programs). It is used to transfer channels to ip-qam/ip-asi modulators and multiplexers. Below are screenshots of most general configuration pages    In the SDT settings should be provided all information about channel: * `Service Name` - program name * `PNR` - program number should be same as in the input list * `LCN` - logical number defines what channel number will be on the TV set  In the NIT settings provide information for DVB-C transponder. ### Setting up the Modulator [Section titled “Setting up the Modulator”](#setting-up-the-modulator) At this point, we have already found and added all the necessary channels in Astra, created a New Stream, and configured the MPTS, which should be sent to the modulator. To configure the Output signal to the RESI DVB-C modulator we need to know the Number of RESI adapters in the system. On the server console find the card number and modulators using the command: ```sh find "/dev/dvb" -name "mod*" ``` In the output - we get the number of the adapter and its modulators like: ```plaintext /dev/dvb/adapter0/mod0 ``` * `adapter0` - adapter number in the system * `mod0` - device number (transponder) on this adapter. Range from 0 to 7 will be for FSM8 modulator Now it is a turn to configure the Output signal to the RESI DVB-C modulator in the MPTS settings  As a result, we should get a fully configured Stream, as shown in the screenshot:  ## Monitor and manage [Section titled “Monitor and manage”](#monitor-and-manage) With Astra, you may Analyze the quality and stability of transport streams. Export statistics and events to external systems like Zabbix or Grafana. Also at any time you may open Astra Web Interface to simply check out the Dashboard. Here you will see already configured Adapters, created Streams, and some useful options like signal strength/quality, bitrate at channels, and so on.    ## Checking the output DVB-C signal [Section titled “Checking the output DVB-C signal”](#checking-the-output-dvb-c-signal) With these simple steps, we have set up our Stream. Now we have the channels converted and modulated with the RESI DVB-C FSM modulator. The best way to check the output signal is to use an analyzer. There are many different models from many manufacturers. For example, Telestar:  Also, we can connect the coaxial cable from RESI to the TV set, and in the TV settings make a new DVB-C channel scan, either Full Scan or Network Scan (or specify the scan parameters manually). Channels search settings fully depend on the TV manufacturer, but in general, they are very similar. ## Troubleshooting DVB receiving [Section titled “Troubleshooting DVB receiving”](#troubleshooting-dvb-receiving) In case you get any issues during configuration, we provide a list of articles on how to identify issues and eliminate the potential cause of the problem: [Troubleshooting DVB receiving](../../troubleshooting/dvb/) We take care of each of our customers and your best experience of working with Cesbo Astra, which is why we offer more support channels such as Online help and support via E-mail. # Fault-tolerant configuration With a fault-tolerant configuration, you can launch a second server to replace the primary in case of failure. ```plaintext astra -c /etc/astra/astra.conf -p 8000 --slave "http://192.168.1.1:8000" ``` This command will start Astra in slave mode and will connect to the primary process on the server at 192.168.1.1. As soon as the connection with the primary server is lost, Astra will execute the configuration and begin operating. By default, Astra executes the configuration in 3 seconds. However, you can set a shorter or longer delay with the `delay` option: ```plaintext astra -c /etc/astra/astra.conf -p 8000 --slave "http://192.168.1.1:8000#delay=10" ```