dvb: add support for DVB-T2

Probably does much more:

+ add support DVB-T2
* DVB params set to AUTO by default
* MAX_CARDS: 4 -> 16
* DMX_SET_BUFFER_SIZE: 64kb -> 256kb
+ add DTV_CLEAR call before tune
+ add logic from https://github.com/olifre/mpv/commits/dvb-mixed-api-scan
* rename type to delsys
* single playlist per adapter
* card -> adapter
* fix channels order in playlist
* update internal api
* auto fallback to old DVB API on tune
* fix DELSYS_SUPP_MASK value
* remove tone - unused
* add channel mem zeroize in config parser
+ add code from libdvbv5 for detect delivery systems
* SYS_DVBC_ANNEX_AC replaced to SYS_DVBC_ANNEX_A + SYS_DVBC_ANNEX_C

Signed-off-by: wm4 <wm4@nowhere>

stream/dvb_tune.c

@@ -1,6 +1,7 @@
 /* dvbtune - tune.c
 
    Copyright (C) Dave Chapman 2001,2002
+   Copyright (C) Rozhuk Ivan <rozhuk.im@gmail.com> 2016
 
    Modified for use with MPlayer, for details see the changelog at
    http://svn.mplayerhq.hu/mplayer/trunk/
@@ -40,111 +41,148 @@
 #include "dvb_tune.h"
 #include "common/msg.h"
 
-int dvb_get_tuner_types(int fe_fd, struct mp_log *log, int** tuner_types)
+/* Keep in sync with enum fe_delivery_system. */
+static const char *dvb_delsys_str[] = {
+    "UNDEFINED",
+    "DVB-C ANNEX A",
+    "DVB-C ANNEX B",
+    "DVB-T",
+    "DSS",
+    "DVB-S",
+    "DVB-S2",
+    "DVB-H",
+    "ISDBT",
+    "ISDBS",
+    "ISDBC",
+    "ATSC",
+    "ATSCMH",
+    "DTMB",
+    "CMMB",
+    "DAB",
+    "DVB-T2",
+    "TURBO",
+    "DVB-C ANNEX C",
+    NULL
+};
+
+const char *get_dvb_delsys(unsigned int delsys)
 {
+    if (SYS_DVB__COUNT__ <= delsys)
+        return dvb_delsys_str[0];
+    return dvb_delsys_str[delsys];
+}
+
+unsigned int dvb_get_tuner_delsys_mask(int fe_fd, struct mp_log *log)
+{
+    unsigned int ret_mask = 0, delsys;
+    struct dtv_property prop[1];
+    struct dtv_properties cmdseq = {.num = 1, .props = prop};
+    struct dvb_frontend_info fe_info;
+
 #ifdef DVB_USE_S2API
     /* S2API is the DVB API new since 2.6.28.
        It allows to query frontends with multiple delivery systems. */
-    struct dtv_property p[] = {{ .cmd = DTV_ENUM_DELSYS }};
-    struct dtv_properties cmdseq = {.num = 1, .props = p};
     mp_verbose(log, "Querying tuner type via DVBv5 API for frontend FD %d\n",
                fe_fd);
-    if ((ioctl(fe_fd, FE_GET_PROPERTY, &cmdseq)) < -0) {
+    prop[0].cmd = DTV_ENUM_DELSYS;
-      mp_err(log, "FE_GET_PROPERTY error: %d, FD: %d\n\n", errno, fe_fd);
+    if (ioctl(fe_fd, FE_GET_PROPERTY, &cmdseq) < 0) {
-      return 0;
+        mp_err(log, "DVBv5: FE_GET_PROPERTY(DTV_ENUM_DELSYS) error: %d, FD: %d\n\n", errno, fe_fd);
+        goto old_api;
     }
-    int num_tuner_types = p[0].u.buffer.len;
+    unsigned int i, delsys_count = prop[0].u.buffer.len;
-    mp_verbose(log, "Number of supported delivery systems: %d\n", num_tuner_types);
+    mp_verbose(log, "DVBv5: Number of supported delivery systems: %d\n", delsys_count);
-    if (num_tuner_types == 0) {
+    if (delsys_count == 0) {
-      mp_err(log, "Frontend FD %d returned no delivery systems!", fe_fd);
+        mp_err(log, "DVBv5: Frontend FD %d returned no delivery systems!\n", fe_fd);
-      return 0;
+        goto old_api;
     }
-    (*tuner_types) = talloc_array(NULL, int, num_tuner_types);
+    for (i = 0; i < delsys_count; i++) {
-    int supported_tuners = 0;
+        delsys = (unsigned int)prop[0].u.buffer.data[i];
-    for(;p[0].u.buffer.len > 0; p[0].u.buffer.len--) {
+        DELSYS_SET(ret_mask, delsys);
-      fe_delivery_system_t delsys = p[0].u.buffer.data[p[0].u.buffer.len - 1];
+        mp_verbose(log, "DVBv5: Tuner type seems to be %s\n", get_dvb_delsys(delsys));
-      /* Second level standards like like DVB-T2, DVB-S2 not treated here -
-         Cards can usually either only do S/T/C or both levels.
-         DVB-T2 probably needs more implementation details,
-         DVB-S2 is treated in the DVB-S branch already. */
-      switch (delsys) {
-      case SYS_DVBT:
-        mp_verbose(log, "Tuner type seems to be DVB-T\n");
-        (*tuner_types)[supported_tuners++] = TUNER_TER;
-        break;
-      case SYS_DVBC_ANNEX_AC:
-        mp_verbose(log, "Tuner type seems to be DVB-C\n");
-        (*tuner_types)[supported_tuners++] = TUNER_CBL;
-        break;
-      case SYS_DVBS:
-        mp_verbose(log, "Tuner type seems to be DVB-S\n");
-        (*tuner_types)[supported_tuners++] = TUNER_SAT;
-        break;
-#ifdef DVB_ATSC
-      case SYS_ATSC:
-        mp_verbose(log, "Tuner type seems to be DVB-ATSC\n");
-        (*tuner_types)[supported_tuners++] = TUNER_ATSC;
-        break;
-#endif
-      case SYS_DVBS2:
-        // We actually handle that in the DVB-S branch, ok to ignore here.
-        mp_verbose(log, "Tuner supports DVB-S2\n");
-        break;
-      default:
-        mp_err(log, "Unhandled tuner type: %d\n", delsys);
-      }
-    }
-    return supported_tuners;
-#else
-    struct dvb_frontend_info fe_info;
-    int res = ioctl(fe_fd, FE_GET_INFO, &fe_info);
-    if (res < 0) {
-        mp_err(log, "FE_GET_INFO error: %d, FD: %d\n\n", errno, fe_fd);
-        return 0;
     }
 
-    mp_verbose(log, "Queried tuner type of device named '%s', FD: %d\n",
+    return ret_mask;
+
+old_api:
+#endif
+    mp_verbose(log, "Querying tuner type via pre-DVBv5 API for frontend FD %d\n",
+               fe_fd);
+
+    memset(&fe_info, 0x00, sizeof(struct dvb_frontend_info));
+    if (ioctl(fe_fd, FE_GET_INFO, &fe_info) < 0) {
+        mp_err(log, "DVBv3: FE_GET_INFO error: %d, FD: %d\n\n", errno, fe_fd);
+        return ret_mask;
+    }
+    /* Try to get kernel DVB API version. */
+    prop[0].cmd = DTV_API_VERSION;
+    if (ioctl(fe_fd, FE_GET_PROPERTY, &cmdseq) < 0) {
+        prop[0].u.data = 0x0300; /* Fail, assume 3.0 */
+    }
+
+    mp_verbose(log, "DVBv3: Queried tuner type of device named '%s', FD: %d\n",
                fe_info.name, fe_fd);
     switch (fe_info.type) {
     case FE_OFDM:
-        mp_verbose(log, "Tuner type seems to be DVB-T\n");
+        DELSYS_SET(ret_mask, SYS_DVBT);
-        *tuner_types = talloc_array(NULL, int, 1);
+        if (prop[0].u.data < 0x0500)
-        (*tuner_types)[0] = TUNER_TER;
+            break;
-        return 1;
+        if (FE_CAN_2G_MODULATION & fe_info.caps) {
+            DELSYS_SET(ret_mask, SYS_DVBT2);
+        }
+        break;
     case FE_QPSK:
-        mp_verbose(log, "Tuner type seems to be DVB-S\n");
+        DELSYS_SET(ret_mask, SYS_DVBS);
-        *tuner_types = talloc_array(NULL, int, 1);
+        if (prop[0].u.data < 0x0500)
-        (*tuner_types)[0] = TUNER_SAT;
+            break;
-        return 1;
+        if (FE_CAN_2G_MODULATION & fe_info.caps) {
+            DELSYS_SET(ret_mask, SYS_DVBS2);
+        }
+#if 0 /* Not used now. */
+        if (FE_CAN_TURBO_FEC & fe_info.caps) {
+            DELSYS_SET(ret_mask, SYS_TURBO);
+        }
+#endif
+        break;
     case FE_QAM:
-        mp_verbose(log, "Tuner type seems to be DVB-C\n");
+        DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_A);
-        *tuner_types = talloc_array(NULL, int, 1);
+        DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_C);
-        (*tuner_types)[0] = TUNER_CBL;
+        break;
-        return 1;
 #ifdef DVB_ATSC
     case FE_ATSC:
-        mp_verbose(log, "Tuner type seems to be DVB-ATSC\n");
+        if ((FE_CAN_8VSB | FE_CAN_16VSB) & fe_info.caps) {
-        *tuner_types = talloc_array(NULL, int, 1);
+            DELSYS_SET(ret_mask, SYS_ATSC);
-        (*tuner_types)[0] = TUNER_ATSC;
+        }
-        return 1;
+#if 0 /* Not used now. */
+        if ((FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_QAM_AUTO) & fe_info.caps) {
+            DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_B);
+        }
+#endif
+        break;
 #endif
     default:
-        mp_err(log, "Unknown tuner type: %d\n", fe_info.type);
+        mp_err(log, "DVBv3: Unknown tuner type: %d\n", fe_info.type);
-        return 0;
+        return ret_mask;
     }
-#endif
+
+    for (delsys = 0; delsys < SYS_DVB__COUNT__; delsys ++) {
+        if (!DELSYS_IS_SET(ret_mask, delsys))
+            continue; /* Skip unsupported. */
+        mp_verbose(log, "DVBv3: Tuner type seems to be %s\n", get_dvb_delsys(delsys));
+    }
+
+    return ret_mask;
 }
 
-int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt)
+int dvb_open_devices(dvb_priv_t *priv, unsigned int n, unsigned int demux_cnt)
 {
-    int i;
+    unsigned int i;
-    char frontend_dev[32], dvr_dev[32], demux_dev[32];
+    char frontend_dev[PATH_MAX], dvr_dev[PATH_MAX], demux_dev[PATH_MAX];
 
     dvb_state_t* state = priv->state;
 
-    sprintf(frontend_dev, "/dev/dvb/adapter%d/frontend0", n);
+    snprintf(frontend_dev, sizeof(frontend_dev), "/dev/dvb/adapter%u/frontend0", n);
-    sprintf(dvr_dev, "/dev/dvb/adapter%d/dvr0", n);
+    snprintf(dvr_dev, sizeof(dvr_dev), "/dev/dvb/adapter%u/dvr0", n);
-    sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", n);
+    snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%u/demux0", n);
     state->fe_fd = open(frontend_dev, O_RDWR | O_NONBLOCK | O_CLOEXEC);
     if (state->fe_fd < 0) {
         MP_ERR(priv, "ERROR OPENING FRONTEND DEVICE %s: ERRNO %d\n",
@@ -165,7 +203,6 @@ int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt)
         }
     }
 
-
     state->dvr_fd = open(dvr_dev, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
     if (state->dvr_fd < 0) {
         MP_ERR(priv, "ERROR OPENING DVR DEVICE %s: %d\n", dvr_dev, errno);
@@ -176,22 +213,23 @@ int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt)
 }
 
 
-int dvb_fix_demuxes(dvb_priv_t *priv, int cnt)
+int dvb_fix_demuxes(dvb_priv_t *priv, unsigned int cnt)
 {
     int i;
-    char demux_dev[32];
+    char demux_dev[PATH_MAX];
 
     dvb_state_t* state = priv->state;
 
-    sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", state->card);
+    snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0",
+            state->adapters[state->cur_adapter].devno);
     MP_VERBOSE(priv, "FIX %d -> %d\n", state->demux_fds_cnt, cnt);
     if (state->demux_fds_cnt >= cnt) {
-        for (i = state->demux_fds_cnt - 1; i >= cnt; i--) {
+        for (i = state->demux_fds_cnt - 1; i >= (int)cnt; i--) {
             MP_VERBOSE(priv, "FIX, CLOSE fd(%d): %d\n", i, state->demux_fds[i]);
             close(state->demux_fds[i]);
         }
         state->demux_fds_cnt = cnt;
-    } else if (state->demux_fds_cnt < cnt) {
+    } else {
         for (i = state->demux_fds_cnt; i < cnt; i++) {
             state->demux_fds[i] = open(demux_dev,
                                       O_RDWR | O_NONBLOCK | O_CLOEXEC);
@@ -220,7 +258,7 @@ int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid,
     pesFilterParams.flags   = DMX_IMMEDIATE_START;
 
     {
-        int buffersize = 64 * 1024;
+        int buffersize = 256 * 1024;
         if (ioctl(fd, DMX_SET_BUFFER_SIZE, buffersize) < 0)
             MP_ERR(priv, "ERROR IN DMX_SET_BUFFER_SIZE %i for fd %d: ERRNO: %d\n",
                    pid, fd, errno);
@@ -238,16 +276,16 @@ int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid,
     return 1;
 }
 
-int dvb_get_pmt_pid(dvb_priv_t *priv, int card, int service_id)
+int dvb_get_pmt_pid(dvb_priv_t *priv, int devno, int service_id)
 {
     /* We need special filters on the demux,
        so open one locally, and close also here. */
-    char demux_dev[32];
+    char demux_dev[PATH_MAX];
-    sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", card);
+    snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0", devno);
 
     struct dmx_sct_filter_params fparams;
 
-    memset(&fparams, 0, sizeof(fparams));
+    memset(&fparams, 0x00, sizeof(fparams));
     fparams.pid = 0;
     fparams.filter.filter[0] = 0x00;
     fparams.filter.mask[0] = 0xff;
@@ -260,7 +298,7 @@ int dvb_get_pmt_pid(dvb_priv_t *priv, int card, int service_id)
         return -1;
     }
 
-    if (ioctl(pat_fd, DMX_SET_FILTER, &fparams) == -1) {
+    if (ioctl(pat_fd, DMX_SET_FILTER, &fparams) < 0) {
         MP_ERR(priv, "ioctl DMX_SET_FILTER failed, error: %d", errno);
         close(pat_fd);
         return -1;
@@ -309,16 +347,6 @@ int dvb_get_pmt_pid(dvb_priv_t *priv, int card, int service_id)
     return pmt_pid;
 }
 
-int dvb_demux_stop(int fd)
-{
-    return ioctl(fd, DMX_STOP) == 0;
-}
-
-int dvb_demux_start(int fd)
-{
-    return ioctl(fd, DMX_START) == 0;
-}
-
 static void print_status(dvb_priv_t *priv, fe_status_t festatus)
 {
     MP_VERBOSE(priv, "FE_STATUS:");
@@ -400,20 +428,21 @@ struct diseqc_cmd {
 static int diseqc_send_msg(int fd, fe_sec_voltage_t v, struct diseqc_cmd *cmd,
                            fe_sec_tone_mode_t t, fe_sec_mini_cmd_t b)
 {
-    if (ioctl(fd, FE_SET_TONE, SEC_TONE_OFF) == -1)
+    if (ioctl(fd, FE_SET_TONE, SEC_TONE_OFF) < 0)
         return -1;
-    if (ioctl(fd, FE_SET_VOLTAGE, v) == -1)
+    if (ioctl(fd, FE_SET_VOLTAGE, v) < 0)
         return -1;
     usleep(15 * 1000);
-    if (ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) == -1)
+    if (ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) < 0)
         return -1;
     usleep(cmd->wait * 1000);
     usleep(15 * 1000);
-    if (ioctl(fd, FE_DISEQC_SEND_BURST, b) == -1)
+    if (ioctl(fd, FE_DISEQC_SEND_BURST, b) < 0)
         return -1;
     usleep(15 * 1000);
-    if (ioctl(fd, FE_SET_TONE, t) == -1)
+    if (ioctl(fd, FE_SET_TONE, t) < 0)
         return -1;
+    usleep(100000);
 
     return 0;
 }
@@ -432,12 +461,12 @@ static int do_diseqc(int secfd, int sat_no, int polv, int hi_lo)
 
     return diseqc_send_msg(secfd, polv ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18,
                            &cmd, hi_lo ? SEC_TONE_ON : SEC_TONE_OFF,
-                           (sat_no / 4) % 2 ? SEC_MINI_B : SEC_MINI_A);
+                           ((sat_no / 4) % 2) ? SEC_MINI_B : SEC_MINI_A);
 }
 
-static int tune_it(dvb_priv_t *priv, int fd_frontend,
+static int tune_it(dvb_priv_t *priv, int fd_frontend, unsigned int delsys,
-                   unsigned int freq, unsigned int srate, char pol, int tone,
+                   unsigned int freq, unsigned int srate, char pol,
-                   bool is_dvb_s2, int stream_id,
+                   int stream_id,
                    fe_spectral_inversion_t specInv, unsigned int diseqc,
                    fe_modulation_t modulation,
                    fe_code_rate_t HP_CodeRate,
@@ -447,36 +476,178 @@ static int tune_it(dvb_priv_t *priv, int fd_frontend,
                    fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier,
                    int timeout)
 {
-    int hi_lo = 0, dfd;
+    int hi_lo = 0, bandwidth_hz = 0;
-
     dvb_state_t* state = priv->state;
-
     struct dvb_frontend_parameters feparams;
 
-    MP_VERBOSE(priv, "TUNE_IT, fd_frontend %d, freq %lu, srate %lu, "
-               "pol %c, tone %i, diseqc %u\n", fd_frontend,
-               (long unsigned int)freq, (long unsigned int)srate, pol,
-               tone, diseqc);
 
-    memset(&feparams, 0, sizeof(feparams));
+    MP_VERBOSE(priv, "TUNE_IT, fd_frontend %d, %s freq %lu, srate %lu, "
+               "pol %c, diseqc %u\n", fd_frontend,
+               get_dvb_delsys(delsys),
+               (long unsigned int)freq, (long unsigned int)srate,
+               (pol > ' ' ? pol : '-'), diseqc);
 
-    MP_VERBOSE(priv, "Using DVB card \"%s\"\n", state->cards[state->card].name);
+    MP_VERBOSE(priv, "Using %s adapter %d\n",
+        get_dvb_delsys(delsys),
+        state->adapters[state->cur_adapter].devno);
 
     {
         /* discard stale QPSK events */
         struct dvb_frontend_event ev;
         while (true) {
-            if (ioctl(fd_frontend, FE_GET_EVENT, &ev) == -1)
+            if (ioctl(fd_frontend, FE_GET_EVENT, &ev) < 0)
                 break;
         }
     }
 
-    switch (state->tuner_type) {
+   /* Prepare params, be verbose. */
-    case TUNER_TER: {
+    switch (delsys) {
+    case SYS_DVBT2:
+#ifndef DVB_USE_S2API
+        MP_ERR(priv, "ERROR: Can not tune to T2 channel, S2-API not "
+                     "available, will tune to DVB-T!\n");
+#endif
+        /* PASSTROUTH. */
+    case SYS_DVBT:
         if (freq < 1000000)
             freq *= 1000UL;
-        feparams.frequency = freq;
+        switch (bandwidth) {
-        feparams.inversion = specInv;
+        case BANDWIDTH_5_MHZ:
+            bandwidth_hz = 5000000;
+            break;
+        case BANDWIDTH_6_MHZ:
+            bandwidth_hz = 6000000;
+            break;
+        case BANDWIDTH_7_MHZ:
+            bandwidth_hz = 7000000;
+            break;
+        case BANDWIDTH_8_MHZ:
+            bandwidth_hz = 8000000;
+            break;
+        case BANDWIDTH_10_MHZ:
+            bandwidth_hz = 10000000;
+            break;
+        case BANDWIDTH_AUTO:
+            if (freq < 474000000) {
+                bandwidth_hz = 7000000;
+            } else {
+                bandwidth_hz = 8000000;
+            }
+            break;
+        default:
+            bandwidth_hz = 0;
+            break;
+        }
+
+        MP_VERBOSE(priv, "tuning %s to %d Hz, bandwidth: %d\n",
+                   get_dvb_delsys(delsys), freq, bandwidth_hz);
+        break;
+    case SYS_DVBS2:
+#ifndef DVB_USE_S2API
+        MP_ERR(priv, "ERROR: Can not tune to S2 channel, S2-API not "
+                     "available, will tune to DVB-S!\n");
+#endif
+        /* PASSTROUTH. */
+    case SYS_DVBS:
+        if (freq > 2200000) {
+            // this must be an absolute frequency
+            if (freq < SLOF) {
+                freq -= LOF1;
+                hi_lo = 0;
+            } else {
+                freq -= LOF2;
+                hi_lo = 1;
+            }
+        }
+        MP_VERBOSE(priv, "tuning %s to Freq: %u, Pol: %c Srate: %d, "
+                   "22kHz: %s, LNB:  %d\n", get_dvb_delsys(delsys), freq,
+                   pol, srate, hi_lo ? "on" : "off", diseqc);
+
+        if (do_diseqc(fd_frontend, diseqc, (pol == 'V' ? 1 : 0), hi_lo) == 0) {
+            MP_VERBOSE(priv, "DISEQC setting succeeded\n");
+        } else {
+            MP_ERR(priv, "DISEQC setting failed\n");
+            return -1;
+        }
+
+        break;
+    case SYS_DVBC_ANNEX_A:
+    case SYS_DVBC_ANNEX_C:
+        MP_VERBOSE(priv, "tuning %s to %d, srate=%d\n",
+                   get_dvb_delsys(delsys), freq, srate);
+        break;
+#ifdef DVB_ATSC
+    case SYS_ATSC:
+        MP_VERBOSE(priv, "tuning %s to %d, modulation=%d\n",
+                   get_dvb_delsys(delsys), freq, modulation);
+        break;
+#endif
+    default:
+        MP_VERBOSE(priv, "Unknown FE type. Aborting\n");
+        return 0;
+    }
+
+#ifdef DVB_USE_S2API
+    /* S2API is the DVB API new since 2.6.28.
+     * It is needed to tune to new delivery systems, e.g. DVB-S2.
+     * It takes a struct with a list of pairs of command + parameter.
+     */
+
+    /* Reset before tune. */
+    struct dtv_property p_clear[] = {
+        { .cmd = DTV_CLEAR },
+    };
+    struct dtv_properties cmdseq_clear = {
+        .num = 1,
+        .props = p_clear
+    };
+    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmdseq_clear) < 0) {
+        MP_ERR(priv, "FE_SET_PROPERTY DTV_CLEAR failed\n");
+    }
+
+    /* Tune. */
+    struct dtv_property p[] = {
+        { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
+        { .cmd = DTV_FREQUENCY, .u.data = freq },
+        { .cmd = DTV_MODULATION, .u.data = modulation },
+        { .cmd = DTV_SYMBOL_RATE, .u.data = srate },
+        { .cmd = DTV_INNER_FEC, .u.data = HP_CodeRate },
+        { .cmd = DTV_INVERSION, .u.data = specInv },
+        { .cmd = DTV_ROLLOFF, .u.data = ROLLOFF_AUTO },
+        { .cmd = DTV_BANDWIDTH_HZ, .u.data = bandwidth_hz },
+        { .cmd = DTV_PILOT, .u.data = PILOT_AUTO },
+        { .cmd = DTV_STREAM_ID, .u.data = stream_id },
+        { .cmd = DTV_TUNE },
+    };
+    struct dtv_properties cmdseq = {
+        .num = sizeof(p) / sizeof(p[0]),
+        .props = p
+    };
+    MP_VERBOSE(priv, "Tuning via S2API, channel is %s.\n",
+               get_dvb_delsys(delsys));
+    if (ioctl(fd_frontend, FE_SET_PROPERTY, &cmdseq) < 0) {
+        MP_ERR(priv, "ERROR tuning channel\n");
+        goto old_api;
+    }
+
+    return check_status(priv, fd_frontend, timeout);
+
+old_api:
+#endif
+
+    MP_VERBOSE(priv, "Tuning via DVB-API version 3.\n");
+
+    if (stream_id != NO_STREAM_ID_FILTER && stream_id != 0) {
+        MP_ERR(priv, "DVB-API version 3 does not support stream_id (PLP).\n");
+        return -1;
+    }
+    memset(&feparams, 0x00, sizeof(feparams));
+    feparams.frequency = freq;
+    feparams.inversion = specInv;
+
+    switch (delsys) {
+    case SYS_DVBT:
+    case SYS_DVBT2:
         feparams.u.ofdm.bandwidth = bandwidth;
         feparams.u.ofdm.code_rate_HP = HP_CodeRate;
         feparams.u.ofdm.code_rate_LP = LP_CodeRate;
@@ -484,168 +655,49 @@ static int tune_it(dvb_priv_t *priv, int fd_frontend,
         feparams.u.ofdm.transmission_mode = TransmissionMode;
         feparams.u.ofdm.guard_interval = guardInterval;
         feparams.u.ofdm.hierarchy_information = hier;
-        MP_VERBOSE(priv, "tuning DVB-T to %d Hz, bandwidth: %d\n",
+        break;
-                   freq, bandwidth);
+    case SYS_DVBS:
-        if (ioctl(fd_frontend, FE_SET_FRONTEND, &feparams) < 0) {
+    case SYS_DVBS2:
-            MP_ERR(priv, "ERROR tuning channel\n");
-            return -1;
-        }
-    }
-    break;
-    case TUNER_SAT: {
-        // DVB-S
-        if (freq > 2200000) {
-            // this must be an absolute frequency
-            if (freq < SLOF) {
-                freq = feparams.frequency = (freq - LOF1);
-                hi_lo = 0;
-            } else {
-                freq = feparams.frequency = (freq - LOF2);
-                hi_lo = 1;
-            }
-        } else {
-            // this is an L-Band frequency
-            feparams.frequency = freq;
-        }
-
-        feparams.inversion = specInv;
         feparams.u.qpsk.symbol_rate = srate;
         feparams.u.qpsk.fec_inner = HP_CodeRate;
-        dfd = fd_frontend;
+        break;
-
+    case SYS_DVBC_ANNEX_A:
-        MP_VERBOSE(priv, "tuning DVB-S%sto Freq: %u, Pol: %c Srate: %d, "
+    case SYS_DVBC_ANNEX_C:
-                   "22kHz: %s, LNB:  %d\n", is_dvb_s2 ? "2 " : " ", freq,
-                   pol, srate, hi_lo ? "on" : "off", diseqc);
-
-        if (do_diseqc(dfd, diseqc, (pol == 'V' ? 1 : 0), hi_lo) == 0) {
-            MP_VERBOSE(priv, "DISEQC setting succeeded\n");
-        } else {
-            MP_ERR(priv, "DISEQC setting failed\n");
-            return -1;
-        }
-        usleep(100000);
-
-#ifdef DVB_USE_S2API
-        /* S2API is the DVB API new since 2.6.28.
-         * It is needed to tune to new delivery systems, e.g. DVB-S2.
-         * It takes a struct with a list of pairs of command + parameter.
-         */
-
-        fe_delivery_system_t delsys = SYS_DVBS;
-        if (is_dvb_s2)
-            delsys = SYS_DVBS2;
-        fe_rolloff_t rolloff = ROLLOFF_AUTO;
-
-        struct dtv_property p[] = {
-            { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
-            { .cmd = DTV_FREQUENCY, .u.data = freq },
-            { .cmd = DTV_MODULATION, .u.data = modulation },
-            { .cmd = DTV_SYMBOL_RATE, .u.data = srate },
-            { .cmd = DTV_INNER_FEC, .u.data = HP_CodeRate },
-            { .cmd = DTV_INVERSION, .u.data = specInv },
-            { .cmd = DTV_ROLLOFF, .u.data = rolloff },
-            { .cmd = DTV_PILOT, .u.data = PILOT_AUTO },
-            { .cmd = DTV_STREAM_ID, .u.data = stream_id },
-            { .cmd = DTV_TUNE },
-        };
-        struct dtv_properties cmdseq = {
-            .num = sizeof(p) / sizeof(p[0]),
-            .props = p
-        };
-        MP_VERBOSE(priv, "Tuning via S2API, channel is DVB-S%s.\n",
-                   is_dvb_s2 ? "2" : "");
-        if ((ioctl(fd_frontend, FE_SET_PROPERTY, &cmdseq)) == -1) {
-            MP_ERR(priv, "ERROR tuning channel\n");
-            return -1;
-        }
-#else
-        MP_VERBOSE(priv, "Tuning via DVB-API version 3.\n");
-        if (is_dvb_s2) {
-            MP_ERR(priv, "ERROR: Can not tune to S2 channel, S2-API not "
-                         "available, will tune to DVB-S!\n");
-        }
-        if (ioctl(fd_frontend, FE_SET_FRONTEND, &feparams) < 0) {
-            MP_ERR(priv, "ERROR tuning channel\n");
-            return -1;
-        }
-#endif
-    }
-    break;
-    case TUNER_CBL: {
-#ifdef DVB_USE_S2API
-        /* S2API is the DVB API new since 2.6.28.
-         * It is also needed for devices supporting multiple delivery systems,
-         * commonly DVB-C + DVB-T are supported here.
-         */
-        fe_delivery_system_t delsys = SYS_DVBC_ANNEX_AC;
-        struct dtv_property p[] = {
-            { .cmd = DTV_DELIVERY_SYSTEM, .u.data = delsys },
-            { .cmd = DTV_FREQUENCY, .u.data = freq },
-            { .cmd = DTV_INVERSION, .u.data = specInv },
-            { .cmd = DTV_MODULATION, .u.data = modulation },
-            { .cmd = DTV_SYMBOL_RATE, .u.data = srate },
-            { .cmd = DTV_INNER_FEC, .u.data = HP_CodeRate },
-            { .cmd = DTV_TUNE },
-        };
-        struct dtv_properties cmdseq = {
-            .num = sizeof(p) / sizeof(p[0]),
-            .props = p
-        };
-        MP_VERBOSE(priv, "tuning DVB-C to %d, srate=%d using DVBv5 API...\n",
-                   freq, srate);
-        if ((ioctl(fd_frontend, FE_SET_PROPERTY, &cmdseq)) == -1) {
-            MP_ERR(priv, "ERROR tuning channel\n");
-            return -1;
-        }
-#else
-        feparams.frequency = freq;
-        feparams.inversion = specInv;
         feparams.u.qam.symbol_rate = srate;
         feparams.u.qam.fec_inner = HP_CodeRate;
         feparams.u.qam.modulation = modulation;
-        MP_VERBOSE(priv, "tuning DVB-C to %d, srate=%d\n", freq, srate);
+        break;
-        if (ioctl(fd_frontend, FE_SET_FRONTEND, &feparams) < 0) {
-            MP_ERR(priv, "ERROR tuning channel\n");
-            return -1;
-        }
-#endif
-    }
-    break;
 #ifdef DVB_ATSC
-    case TUNER_ATSC: {
+    case SYS_ATSC:
-        feparams.frequency = freq;
         feparams.u.vsb.modulation = modulation;
-        MP_VERBOSE(priv, "tuning ATSC to %d, modulation=%d\n", freq, modulation);
+        break;
-        if (ioctl(fd_frontend, FE_SET_FRONTEND, &feparams) < 0) {
-            MP_ERR(priv, "ERROR tuning channel\n");
-            return -1;
-        }
-    }
-    break;
 #endif
-    default:
+    }
-        MP_VERBOSE(priv, "Unknown FE type. Aborting\n");
+
-        return 0;
+    if (ioctl(fd_frontend, FE_SET_FRONTEND, &feparams) < 0) {
+        MP_ERR(priv, "ERROR tuning channel\n");
+        return -1;
     }
 
     return check_status(priv, fd_frontend, timeout);
 }
 
-int dvb_tune(dvb_priv_t *priv, int freq, char pol, int srate, int diseqc,
+int dvb_tune(dvb_priv_t *priv, unsigned int delsys,
-             int tone,
+             int freq, char pol, int srate, int diseqc,
-             bool is_dvb_s2, int stream_id, fe_spectral_inversion_t specInv,
+             int stream_id, fe_spectral_inversion_t specInv,
              fe_modulation_t modulation, fe_guard_interval_t guardInterval,
              fe_transmit_mode_t TransmissionMode, fe_bandwidth_t bandWidth,
              fe_code_rate_t HP_CodeRate,
              fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier,
              int timeout)
 {
-    MP_INFO(priv, "dvb_tune Freq: %lu\n", (long unsigned int) freq);
+    MP_INFO(priv, "dvb_tune %s Freq: %lu\n",
+            get_dvb_delsys(delsys), (long unsigned int) freq);
 
     dvb_state_t* state = priv->state;
 
-    int ris = tune_it(priv, state->fe_fd, freq, srate, pol, tone,
+    int ris = tune_it(priv, state->fe_fd, delsys, freq, srate, pol,
-                      is_dvb_s2, stream_id, specInv, diseqc, modulation,
+                      stream_id, specInv, diseqc, modulation,
                       HP_CodeRate, TransmissionMode, guardInterval,
                       bandWidth, LP_CodeRate, hier, timeout);
 

stream/dvb_tune.h

@@ -23,15 +23,16 @@
 
 struct mp_log;
 
-int dvb_get_tuner_types(int fe_fd, struct mp_log *log, int** tuner_types);
+
-int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt);
+const char *get_dvb_delsys(unsigned int delsys);
-int dvb_fix_demuxes(dvb_priv_t *priv, int cnt);
+unsigned int dvb_get_tuner_delsys_mask(int fe_fd, struct mp_log *log);
+int dvb_open_devices(dvb_priv_t *priv, unsigned int n, unsigned int demux_cnt);
+int dvb_fix_demuxes(dvb_priv_t *priv, unsigned int cnt);
 int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid, dmx_pes_type_t pestype);
 int dvb_get_pmt_pid(dvb_priv_t *priv, int card, int service_id);
-int dvb_demux_stop(int fd);
+int dvb_tune(dvb_priv_t *priv, unsigned int delsys,
-int dvb_demux_start(int fd);
+             int freq, char pol, int srate, int diseqc,
-int dvb_tune(dvb_priv_t *priv, int freq, char pol, int srate, int diseqc,
+             int stream_id, fe_spectral_inversion_t specInv,
-             int tone, bool is_dvb_s2, int stream_id, fe_spectral_inversion_t specInv,
              fe_modulation_t modulation, fe_guard_interval_t guardInterval,
              fe_transmit_mode_t TransmissionMode, fe_bandwidth_t bandWidth,
              fe_code_rate_t HP_CodeRate, fe_code_rate_t LP_CodeRate,

stream/dvbin.h

@@ -62,12 +62,13 @@
 
 typedef struct {
     char *name;
-    int freq, srate, diseqc, tone;
+    unsigned int freq, srate, diseqc;
     char pol;
-    int tpid, dpid1, dpid2, progid, ca, pids[DMX_FILTER_SIZE], pids_cnt;
+    unsigned int tpid, dpid1, dpid2, progid, ca, pids[DMX_FILTER_SIZE], pids_cnt;
-    bool is_dvb_s2;
+    bool is_dvb_x2;
-    int stream_id;
+    unsigned int delsys;
-    int service_id;
+    unsigned int stream_id;
+    unsigned int service_id;
     fe_spectral_inversion_t inv;
     fe_modulation_t mod;
     fe_transmit_mode_t trans;
@@ -78,57 +79,96 @@ typedef struct {
 } dvb_channel_t;
 
 typedef struct {
-    uint16_t NUM_CHANNELS;
+    unsigned int NUM_CHANNELS;
-    uint16_t current;
+    unsigned int current;
     dvb_channel_t *channels;
-} dvb_channels_list;
+} dvb_channels_list_t;
 
 typedef struct {
-    int type;
-    dvb_channels_list *list;
-    char *name;
     int devno;
-} dvb_card_config_t;
+    unsigned int delsys_mask;
+    dvb_channels_list_t *list;
+} dvb_adapter_config_t;
 
 typedef struct {
-    int count;
+    unsigned int adapters_count;
-    dvb_card_config_t *cards;
+    dvb_adapter_config_t *adapters;
+    unsigned int cur_adapter;
 
-    int card;
     int fe_fd;
     int dvr_fd;
     int demux_fd[3], demux_fds[DMX_FILTER_SIZE], demux_fds_cnt;
 
-    dvb_channels_list *list;
-    int tuner_type;
     int is_on;
     int retry;
     int timeout;
-    int last_freq;
+    unsigned int last_freq;
     bool switching_channel;
     bool stream_used;
 } dvb_state_t;
 
-typedef struct dvb_params {
+typedef struct {
     struct mp_log *log;
 
     dvb_state_t *state;
 
     char *cfg_prog;
-    int cfg_card;
+    int cfg_devno;
     int cfg_timeout;
     char *cfg_file;
 
     int cfg_full_transponder;
 } dvb_priv_t;
 
-#define TUNER_SAT       1
+
-#define TUNER_TER       2
+/* Keep in sync with enum fe_delivery_system. */
-#define TUNER_CBL       3
+#ifndef DVB_USE_S2API
-#define TUNER_ATSC      4
+#    define SYS_DVBC_ANNEX_A        1
+#    define SYS_DVBT                3
+#    define SYS_DVBS                5
+#    define SYS_DVBS2               6
+#    define SYS_ATSC                11
+#    define SYS_DVBT2               16
+#    define SYS_DVBC_ANNEX_C        18
+#endif
+#define SYS_DVB__COUNT__            (SYS_DVBC_ANNEX_C + 1)
+
+
+#define DELSYS_BIT(__bit)        (((unsigned int)1) << (__bit))
+
+#define DELSYS_SET(__mask, __bit)                                       \
+    (__mask) |= DELSYS_BIT((__bit))
+
+#define DELSYS_IS_SET(__mask, __bit)                                    \
+    (0 != ((__mask) & DELSYS_BIT((__bit))))
+
+
+#ifdef DVB_ATSC
+#define DELSYS_SUPP_MASK                                                \
+    (                                                                   \
+        DELSYS_BIT(SYS_DVBC_ANNEX_A) |                                  \
+        DELSYS_BIT(SYS_DVBT) |                                          \
+        DELSYS_BIT(SYS_DVBS) |                                          \
+        DELSYS_BIT(SYS_DVBS2) |                                         \
+        DELSYS_BIT(SYS_ATSC) |                                          \
+        DELSYS_BIT(SYS_DVBT2) |                                         \
+        DELSYS_BIT(SYS_DVBC_ANNEX_C)                                    \
+    )
+#else
+#define DELSYS_SUPP_MASK                                                \
+    (                                                                   \
+        DELSYS_BIT(SYS_DVBC_ANNEX_A) |                                  \
+        DELSYS_BIT(SYS_DVBT) |                                          \
+        DELSYS_BIT(SYS_DVBS) |                                          \
+        DELSYS_BIT(SYS_DVBS2) |                                         \
+        DELSYS_BIT(SYS_DVBT2) |                                         \
+        DELSYS_BIT(SYS_DVBC_ANNEX_C)                                    \
+    )
+#endif
+
 
 int dvb_step_channel(stream_t *, int);
-int dvb_set_channel(stream_t *, int, int);
+int dvb_set_channel(stream_t *, unsigned int, unsigned int);
 dvb_state_t *dvb_get_state(stream_t *);
 void dvb_free_state(dvb_state_t *);