summaryrefslogtreecommitdiffstats
path: root/stream/dvb_tune.c
blob: b83da040d0a4b09cd3c5aea711bba99af438e762 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
/* dvbtune - tune.c

   Copyright (C) Dave Chapman 2001,2002

   Modified for use with MPlayer, for details see the changelog at
   http://svn.mplayerhq.hu/mplayer/trunk/
   $Id$

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
   Or, point your browser to http://www.gnu.org/copyleft/gpl.html

*/

#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
#include <linux/dvb/dmx.h>
#include <linux/dvb/frontend.h>

#include "config.h"
#include "osdep/io.h"
#include "dvbin.h"
#include "dvb_tune.h"
#include "common/msg.h"

int dvb_get_tuner_types(int fe_fd, struct mp_log *log, int** tuner_types)
{
#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) {
      mp_err(log, "FE_GET_PROPERTY error: %d, FD: %d\n\n", errno, fe_fd);
      return 0;
    }
    int num_tuner_types = p[0].u.buffer.len;
    mp_verbose(log, "Number of supported delivery systems: %d\n", num_tuner_types);
    if (num_tuner_types == 0) {
      mp_err(log, "Frontend FD %d returned no delivery systems!", fe_fd);
      return 0;
    }
    (*tuner_types) = talloc_array(NULL, int, num_tuner_types);
    int supported_tuners = 0;
    for(;p[0].u.buffer.len > 0; p[0].u.buffer.len--) {
      fe_delivery_system_t delsys = p[0].u.buffer.data[p[0].u.buffer.len - 1];
      /* 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",
               fe_info.name, fe_fd);
    switch (fe_info.type) {
    case FE_OFDM:
        mp_verbose(log, "Tuner type seems to be DVB-T\n");
        *tuner_types = talloc_array(NULL, int, 1);
        (*tuner_types)[0] = TUNER_TER;
        return 1;
    case FE_QPSK:
        mp_verbose(log, "Tuner type seems to be DVB-S\n");
        *tuner_types = talloc_array(NULL, int, 1);
        (*tuner_types)[0] = TUNER_SAT;
        return 1;
    case FE_QAM:
        mp_verbose(log, "Tuner type seems to be DVB-C\n");
        *tuner_types = talloc_array(NULL, int, 1);
        (*tuner_types)[0] = TUNER_CBL;
        return 1;
#ifdef DVB_ATSC
    case FE_ATSC:
        mp_verbose(log, "Tuner type seems to be DVB-ATSC\n");
        *tuner_types = talloc_array(NULL, int, 1);
        (*tuner_types)[0] = TUNER_ATSC;
        return 1;
#endif
    default:
        mp_err(log, "Unknown tuner type: %d\n", fe_info.type);
        return 0;
    }
#endif
}

int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt)
{
    int i;
    char frontend_dev[32], dvr_dev[32], demux_dev[32];

    dvb_state_t* state = priv->state;

    sprintf(frontend_dev, "/dev/dvb/adapter%d/frontend0", n);
    sprintf(dvr_dev, "/dev/dvb/adapter%d/dvr0", n);
    sprintf(demux_dev, "/dev/dvb/adapter%d/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",
               frontend_dev, errno);
        return 0;
    }
    state->demux_fds_cnt = 0;
    MP_VERBOSE(priv, "DVB_OPEN_DEVICES(%d)\n", demux_cnt);
    for (i = 0; i < demux_cnt; i++) {
        state->demux_fds[i] = open(demux_dev, O_RDWR | O_NONBLOCK | O_CLOEXEC);
        if (state->demux_fds[i] < 0) {
            MP_ERR(priv, "ERROR OPENING DEMUX 0: %d\n", errno);
            return 0;
        } else {
            MP_VERBOSE(priv, "OPEN(%d), file %s: FD=%d, CNT=%d\n", i, demux_dev,
                       state->demux_fds[i], state->demux_fds_cnt);
            state->demux_fds_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);
        return 0;
    }

    return 1;
}


int dvb_fix_demuxes(dvb_priv_t *priv, int cnt)
{
    int i;
    char demux_dev[32];

    dvb_state_t* state = priv->state;

    sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", state->card);
    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--) {
            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) {
        for (i = state->demux_fds_cnt; i < cnt; i++) {
            state->demux_fds[i] = open(demux_dev,
                                      O_RDWR | O_NONBLOCK | O_CLOEXEC);
            MP_VERBOSE(priv, "FIX, OPEN fd(%d): %d\n", i, state->demux_fds[i]);
            if (state->demux_fds[i] < 0) {
                MP_ERR(priv, "ERROR OPENING DEMUX 0: %d\n", errno);
                return 0;
            } else
                state->demux_fds_cnt++;
        }
    }

    return 1;
}

int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid,
                    dmx_pes_type_t pestype)
{
    int i;
    struct dmx_pes_filter_params pesFilterParams;

    pesFilterParams.pid     = pid;
    pesFilterParams.input   = DMX_IN_FRONTEND;
    pesFilterParams.output  = DMX_OUT_TS_TAP;
    pesFilterParams.pes_type = pestype;
    pesFilterParams.flags   = DMX_IMMEDIATE_START;

    {
        int buffersize = 64 * 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);
    }

    errno = 0;
    if ((i = ioctl(fd, DMX_SET_PES_FILTER, &pesFilterParams)) < 0) {
        MP_ERR(priv, "ERROR IN SETTING DMX_FILTER %i for fd %d: ERRNO: %d\n",
               pid, fd, errno);
        return 0;
    }

    MP_VERBOSE(priv, "SET PES FILTER ON PID %d to fd %d, RESULT: %d, ERRNO: %d\n",
               pid, fd, i, errno);
    return 1;
}

int dvb_get_pmt_pid(dvb_priv_t *priv, int card, int service_id)
{
    /* We need special filters on the demux,
       so open one locally, and close also here. */
    char demux_dev[32];
    sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", card);

    struct dmx_sct_filter_params fparams;

    memset(&fparams, 0, sizeof(fparams));
    fparams.pid = 0;
    fparams.filter.filter[0] = 0x00;
    fparams.filter.mask[0] = 0xff;
    fparams.timeout = 0;
    fparams.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;

    int pat_fd;
    if ((pat_fd = open(demux_dev, O_RDWR)) < 0) {
        MP_ERR(priv, "Opening PAT DEMUX failed, error: %d", errno);
        return -1;
    }

    if (ioctl(pat_fd, DMX_SET_FILTER, &fparams) == -1) {
        MP_ERR(priv, "ioctl DMX_SET_FILTER failed, error: %d", errno);
        close(pat_fd);
        return -1;
    }

    int bytes_read;
    int section_length;
    unsigned char buft[4096];
    unsigned char *bufptr = buft;

    int pmt_pid = -1;

    bool pat_read = false;
    while (!pat_read) {
        if (((bytes_read =
                  read(pat_fd, bufptr,
                       sizeof(buft))) < 0) && errno == EOVERFLOW)
            bytes_read = read(pat_fd, bufptr, sizeof(buft));
        if (bytes_read < 0) {
            MP_ERR(priv, "PAT: read_sections: read error: %d", errno);
            close(pat_fd);
            return -1;
        }

        section_length = ((bufptr[1] & 0x0f) << 8) | bufptr[2];
        if (bytes_read != section_length + 3)
            continue;

        bufptr += 8;
        section_length -= 8;

        /* assumes one section contains the whole pat */
        pat_read = true;
        while (section_length > 0) {
            int this_service_id = (bufptr[0] << 8) | bufptr[1];
            if (this_service_id == service_id) {
                pmt_pid = ((bufptr[2] & 0x1f) << 8) | bufptr[3];
                section_length = 0;
            }
            bufptr += 4;
            section_length -= 4;
        }
    }
    close(pat_fd);

    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:");
    if (festatus & FE_HAS_SIGNAL)
        MP_VERBOSE(priv, " FE_HAS_SIGNAL");
    if (festatus & FE_TIMEDOUT)
        MP_VERBOSE(priv, " FE_TIMEDOUT");
    if (festatus & FE_HAS_LOCK)
        MP_VERBOSE(priv, " FE_HAS_LOCK");
    if (festatus & FE_HAS_CARRIER)
        MP_VERBOSE(priv, " FE_HAS_CARRIER");
    if (festatus & FE_HAS_VITERBI)
        MP_VERBOSE(priv, " FE_HAS_VITERBI");
    if (festatus & FE_HAS_SYNC)
        MP_VERBOSE(priv, " FE_HAS_SYNC");
    MP_VERBOSE(priv, "\n");
}

static int check_status(dvb_priv_t *priv, int fd_frontend, int tmout)
{
    int32_t strength;
    fe_status_t festatus;
    struct pollfd pfd[1];
    int ok = 0, locks = 0;
    time_t tm1, tm2;

    pfd[0].fd = fd_frontend;
    pfd[0].events = POLLPRI;

    MP_VERBOSE(priv, "Getting frontend status\n");
    tm1 = tm2 = time((time_t *) NULL);
    while (!ok) {
        festatus = 0;
        if (poll(pfd, 1, tmout * 1000) > 0) {
            if (pfd[0].revents & POLLPRI) {
                if (ioctl(fd_frontend, FE_READ_STATUS, &festatus) >= 0) {
                    if (festatus & FE_HAS_LOCK)
                        locks++;
                }
            }
        }
        usleep(10000);
        tm2 = time((time_t *) NULL);
        if ((festatus & FE_TIMEDOUT) || (locks >= 2) || (tm2 - tm1 >= tmout))
            ok = 1;
    }

    if (festatus & FE_HAS_LOCK) {
        strength = 0;
        if (ioctl(fd_frontend, FE_READ_BER, &strength) >= 0)
            MP_VERBOSE(priv, "Bit error rate: %d\n", strength);

        strength = 0;
        if (ioctl(fd_frontend, FE_READ_SIGNAL_STRENGTH, &strength) >= 0)
            MP_VERBOSE(priv, "Signal strength: %d\n", strength);

        strength = 0;
        if (ioctl(fd_frontend, FE_READ_SNR, &strength) >= 0)
            MP_VERBOSE(priv, "SNR: %d\n", strength);

        strength = 0;
        if (ioctl(fd_frontend, FE_READ_UNCORRECTED_BLOCKS, &strength) >= 0)
            MP_VERBOSE(priv, "UNC: %d\n", strength);

        print_status(priv, festatus);
    } else {
        MP_ERR(priv, "Not able to lock to the signal on the given frequency, "
               "timeout: %d\n", tmout);
        return -1;
    }
    return 0;
}

struct diseqc_cmd {
    struct dvb_diseqc_master_cmd cmd;
    uint32_t wait;
};

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)
        return -1;
    if (ioctl(fd, FE_SET_VOLTAGE, v) == -1)
        return -1;
    usleep(15 * 1000);
    if (ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) == -1)
        return -1;
    usleep(cmd->wait * 1000);
    usleep(15 * 1000);
    if (ioctl(fd, FE_DISEQC_SEND_BURST, b) == -1)
        return -1;
    usleep(15 * 1000);
    if (ioctl(fd, FE_SET_TONE, t) == -1)
        return -1;

    return 0;
}

/* digital satellite equipment control,
 * specification is available from http://www.eutelsat.com/
 */
static int do_diseqc(int secfd, int sat_no, int polv, int hi_lo)
{
    struct diseqc_cmd cmd =  { {{0xe0, 0x10, 0x38, 0xf0, 0x00, 0x00}, 4}, 0 };

    /* param: high nibble: reset bits, low nibble set bits,
     * bits are: option, position, polarizaion, band
     */
    cmd.cmd.msg[3] = 0xf0 | (((sat_no * 4) & 0x0f) | (hi_lo ? 1 : 0) | (polv ? 0 : 2));

    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);
}

static int tune_it(dvb_priv_t *priv, int fd_frontend,
                   unsigned int freq, unsigned int srate, char pol, int tone,
                   bool is_dvb_s2, int stream_id,
                   fe_spectral_inversion_t specInv, unsigned int diseqc,
                   fe_modulation_t modulation,
                   fe_code_rate_t HP_CodeRate,
                   fe_transmit_mode_t TransmissionMode,
                   fe_guard_interval_t guardInterval,
                   fe_bandwidth_t bandwidth,
                   fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier,
                   int timeout)
{
    int hi_lo = 0, dfd;

    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, "Using DVB card \"%s\"\n", state->cards[state->card].name);

    {
        /* discard stale QPSK events */
        struct dvb_frontend_event ev;
        while (true) {
            if (ioctl(fd_frontend, FE_GET_EVENT, &ev) == -1)
                break;
        }
    }

    switch (state->tuner_type) {
    case TUNER_TER: {
        if (freq < 1000000)
            freq *= 1000UL;
        feparams.frequency = freq;
        feparams.inversion = specInv;
        feparams.u.ofdm.bandwidth = bandwidth;
        feparams.u.ofdm.code_rate_HP = HP_CodeRate;
        feparams.u.ofdm.code_rate_LP = LP_CodeRate;
        feparams.u.ofdm.constellation = modulation;
        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",
                   freq, bandwidth);
        if (ioctl(fd_frontend, FE_SET_FRONTEND, &feparams) < 0) {
            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;

        MP_VERBOSE(priv, "tuning DVB-S%sto Freq: %u, Pol: %c Srate: %d, "
                   "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);
        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: {
        feparams.frequency = freq;
        feparams.u.vsb.modulation = modulation;
        MP_VERBOSE(priv, "tuning ATSC to %d, modulation=%d\n", freq, modulation);
        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;
    }

    return check_status(priv, fd_frontend, timeout);
}

int dvb_tune(dvb_priv_t *priv, int freq, char pol, int srate, int diseqc,
             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, fe_hierarchy_t hier,
             int timeout)
{
    MP_INFO(priv, "dvb_tune Freq: %lu\n", (long unsigned int) freq);

    dvb_state_t* state = priv->state;

    int ris = tune_it(priv, state->fe_fd, freq, srate, pol, tone,
                      is_dvb_s2, stream_id, specInv, diseqc, modulation,
                      HP_CodeRate, TransmissionMode, guardInterval,
                      bandWidth, LP_CodeRate, hier, timeout);

    if (ris != 0)
        MP_INFO(priv, "dvb_tune, TUNING FAILED\n");

    return ris == 0;
}