From 05f63edc7bcede1c0e1b8580b3f973d09e774a08 Mon Sep 17 00:00:00 2001 From: wm4 Date: Tue, 14 Feb 2017 13:30:59 +0100 Subject: Revert "dvb: add support for DVB-T2" This reverts commit df91e492fd3365cf7db9c6ba4a721f8fcce0521c. Multiple issues such as weird code with undefined behavior (like (like conf_file*). The PR wasn't properly reviewed anyway (my error), so this commit should be reviewed and then merged again. --- stream/dvb_tune.c | 550 ++++++++++++++++++++++++------------------------------ 1 file changed, 249 insertions(+), 301 deletions(-) (limited to 'stream/dvb_tune.c') diff --git a/stream/dvb_tune.c b/stream/dvb_tune.c index a8c6450805..b83da040d0 100644 --- a/stream/dvb_tune.c +++ b/stream/dvb_tune.c @@ -1,7 +1,6 @@ /* dvbtune - tune.c Copyright (C) Dave Chapman 2001,2002 - Copyright (C) Rozhuk Ivan 2016 Modified for use with MPlayer, for details see the changelog at http://svn.mplayerhq.hu/mplayer/trunk/ @@ -41,148 +40,111 @@ #include "dvb_tune.h" #include "common/msg.h" -/* 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) +int dvb_get_tuner_types(int fe_fd, struct mp_log *log, int** tuner_types) { - 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); - prop[0].cmd = DTV_ENUM_DELSYS; - if (ioctl(fe_fd, FE_GET_PROPERTY, &cmdseq) < 0) { - mp_err(log, "DVBv5: FE_GET_PROPERTY(DTV_ENUM_DELSYS) error: %d, FD: %d\n\n", errno, fe_fd); - goto old_api; - } - unsigned int i, delsys_count = prop[0].u.buffer.len; - mp_verbose(log, "DVBv5: Number of supported delivery systems: %d\n", delsys_count); - if (delsys_count == 0) { - mp_err(log, "DVBv5: Frontend FD %d returned no delivery systems!\n", fe_fd); - goto old_api; + 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; } - for (i = 0; i < delsys_count; i++) { - delsys = (unsigned int)prop[0].u.buffer.data[i]; - DELSYS_SET(ret_mask, delsys); - mp_verbose(log, "DVBv5: Tuner type seems to be %s\n", get_dvb_delsys(delsys)); + 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; } - - return ret_mask; - -old_api: + (*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 - mp_verbose(log, "Querying tuner type via pre-DVBv5 API for frontend FD %d\n", - fe_fd); - - memset(&fe_info, 0, 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; + 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); + } } - /* 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 */ + 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, "DVBv3: Queried tuner type of device named '%s', FD: %d\n", + 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: - DELSYS_SET(ret_mask, SYS_DVBT); - if (prop[0].u.data < 0x0500) - break; - if (FE_CAN_2G_MODULATION & fe_info.caps) { - DELSYS_SET(ret_mask, SYS_DVBT2); - } - break; + 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: - DELSYS_SET(ret_mask, SYS_DVBS); - if (prop[0].u.data < 0x0500) - break; - if (FE_CAN_2G_MODULATION & fe_info.caps) { - DELSYS_SET(ret_mask, SYS_DVBS2); - } -#ifdef __not_yet__ - if (FE_CAN_TURBO_FEC & fe_info.caps) { - DELSYS_SET(ret_mask, SYS_TURBO); - } -#endif - break; + 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: - DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_A); - DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_C); - break; + 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: - if ((FE_CAN_8VSB | FE_CAN_16VSB) & fe_info.caps) { - DELSYS_SET(ret_mask, SYS_ATSC); - } -#ifdef __not_yet__ - 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; + 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, "DVBv3: Unknown tuner type: %d\n", fe_info.type); - return ret_mask; - } - - 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)); + mp_err(log, "Unknown tuner type: %d\n", fe_info.type); + return 0; } - - return ret_mask; +#endif } -int dvb_open_devices(dvb_priv_t *priv, unsigned int n, unsigned int demux_cnt) +int dvb_open_devices(dvb_priv_t *priv, int n, int demux_cnt) { - unsigned int i; - char frontend_dev[PATH_MAX], dvr_dev[PATH_MAX], demux_dev[PATH_MAX]; + int i; + char frontend_dev[32], dvr_dev[32], demux_dev[32]; dvb_state_t* state = priv->state; - snprintf(frontend_dev, sizeof(frontend_dev), "/dev/dvb/adapter%d/frontend0", n); - snprintf(dvr_dev, sizeof(dvr_dev), "/dev/dvb/adapter%d/dvr0", n); - snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0", n); + 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", @@ -203,6 +165,7 @@ int dvb_open_devices(dvb_priv_t *priv, unsigned int n, unsigned 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); @@ -213,23 +176,22 @@ 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_fix_demuxes(dvb_priv_t *priv, int cnt) { int i; - char demux_dev[PATH_MAX]; + char demux_dev[32]; dvb_state_t* state = priv->state; - snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0", - state->adapters[state->cur_adapter].devno); + 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 >= (int)cnt; i--) { + 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 { + } 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); @@ -258,7 +220,7 @@ int dvb_set_ts_filt(dvb_priv_t *priv, int fd, uint16_t pid, pesFilterParams.flags = DMX_IMMEDIATE_START; { - int buffersize = 256 * 1024; + 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); @@ -276,12 +238,12 @@ 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 devno, int service_id) +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[PATH_MAX]; - snprintf(demux_dev, sizeof(demux_dev), "/dev/dvb/adapter%d/demux0", devno); + char demux_dev[32]; + sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", card); struct dmx_sct_filter_params fparams; @@ -298,7 +260,7 @@ int dvb_get_pmt_pid(dvb_priv_t *priv, int devno, int service_id) return -1; } - if (ioctl(pat_fd, DMX_SET_FILTER, &fparams) < 0) { + 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; @@ -347,6 +309,16 @@ int dvb_get_pmt_pid(dvb_priv_t *priv, int devno, 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:"); @@ -428,21 +400,20 @@ 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) < 0) + if (ioctl(fd, FE_SET_TONE, SEC_TONE_OFF) == -1) return -1; - if (ioctl(fd, FE_SET_VOLTAGE, v) < 0) + if (ioctl(fd, FE_SET_VOLTAGE, v) == -1) return -1; usleep(15 * 1000); - if (ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) < 0) + 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) < 0) + if (ioctl(fd, FE_DISEQC_SEND_BURST, b) == -1) return -1; usleep(15 * 1000); - if (ioctl(fd, FE_SET_TONE, t) < 0) + if (ioctl(fd, FE_SET_TONE, t) == -1) return -1; - usleep(100000); return 0; } @@ -464,9 +435,9 @@ static int do_diseqc(int secfd, int sat_no, int polv, int hi_lo) (sat_no / 4) % 2 ? SEC_MINI_B : SEC_MINI_A); } -static int tune_it(dvb_priv_t *priv, int fd_frontend, unsigned int delsys, - unsigned int freq, unsigned int srate, char pol, - int stream_id, +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, @@ -476,228 +447,205 @@ static int tune_it(dvb_priv_t *priv, int fd_frontend, unsigned int delsys, fe_code_rate_t LP_CodeRate, fe_hierarchy_t hier, int timeout) { - int hi_lo = 0, bandwidth_hz = 0; + 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); - 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); + memset(&feparams, 0, sizeof(feparams)); - MP_VERBOSE(priv, "Using %s adapter %d\n", - get_dvb_delsys(delsys), - state->adapters[state->cur_adapter].devno); + 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) < 0) + if (ioctl(fd_frontend, FE_GET_EVENT, &ev) == -1) break; } } - /* Prepare params, be verbose. */ - 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: + switch (state->tuner_type) { + case TUNER_TER: { if (freq < 1000000) freq *= 1000UL; - switch (bandwidth) { - 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; + 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; } - - 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: + } + break; + case TUNER_SAT: { + // DVB-S if (freq > 2200000) { // this must be an absolute frequency if (freq < SLOF) { - freq -= LOF1; + freq = feparams.frequency = (freq - LOF1); hi_lo = 0; } else { - freq -= LOF2; + freq = feparams.frequency = (freq - LOF2); hi_lo = 1; } + } else { + // this is an L-Band frequency + feparams.frequency = freq; } - MP_VERBOSE(priv, "tuning %s to Freq: %u, Pol: %c Srate: %d, " - "22kHz: %s, LNB: %d\n", get_dvb_delsys(delsys), 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(fd_frontend, diseqc, (pol == 'V' ? 1 : 0), hi_lo) == 0) { + 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; } - - 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; - } + 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. - */ - - /* 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: + /* 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 - - 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, 0, 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; - feparams.u.ofdm.constellation = modulation; - feparams.u.ofdm.transmission_mode = TransmissionMode; - feparams.u.ofdm.guard_interval = guardInterval; - feparams.u.ofdm.hierarchy_information = hier; - break; - case SYS_DVBS: - case SYS_DVBS2: - feparams.u.qpsk.symbol_rate = srate; - feparams.u.qpsk.fec_inner = HP_CodeRate; - break; - case SYS_DVBC_ANNEX_A: - case SYS_DVBC_ANNEX_C: + 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; - break; + 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 SYS_ATSC: + case TUNER_ATSC: { + feparams.frequency = freq; feparams.u.vsb.modulation = modulation; - break; -#endif + 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; + } } - - 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, unsigned int delsys, - int freq, char pol, int srate, int diseqc, - int stream_id, fe_spectral_inversion_t specInv, +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 %s Freq: %lu\n", - get_dvb_delsys(delsys), (long unsigned int) freq); + 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, delsys, freq, srate, pol, - stream_id, specInv, diseqc, modulation, + 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); -- cgit v1.2.3