RepoMirrors/mpv
1
0
Fork 0
mirror of https://github.com/mpv-player/mpv synced 2025-03-20 18:28:01 +00:00
Code Issues Releases Wiki Activity

dvb: add support for DVB-T2

Browse Source 
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>
This commit is contained in:
ivan-83 2017-02-13 04:55:35 +03:00 committed by wm4
parent b5bb006173
commit e40c41de19
4 changed files with 796 additions and 652 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

580
stream/dvb_tune.c
View File

@ -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) {
mp_err(log, "FE_GET_PROPERTY error: %d, FD: %d\n\n", errno, fe_fd);
return 0;
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;
}
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;
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;
}
(*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;
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));
}
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");
*tuner_types = talloc_array(NULL, int, 1);
(*tuner_types)[0] = TUNER_TER;
return 1;
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;
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;
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);
}
#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");
*tuner_types = talloc_array(NULL, int, 1);
(*tuner_types)[0] = TUNER_CBL;
return 1;
DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_A);
DELSYS_SET(ret_mask, SYS_DVBC_ANNEX_C);
break;
#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;
if ((FE_CAN_8VSB | FE_CAN_16VSB) & fe_info.caps) {
DELSYS_SET(ret_mask, SYS_ATSC);
}
#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);
return 0;
mp_err(log, "DVBv3: Unknown tuner type: %d\n", fe_info.type);
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;
char frontend_dev[32], dvr_dev[32], demux_dev[32];
unsigned int i;
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);
sprintf(dvr_dev, "/dev/dvb/adapter%d/dvr0", n);
sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", n);
snprintf(frontend_dev, sizeof(frontend_dev), "/dev/dvb/adapter%u/frontend0", n);
snprintf(dvr_dev, sizeof(dvr_dev), "/dev/dvb/adapter%u/dvr0", 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];
sprintf(demux_dev, "/dev/dvb/adapter%d/demux0", card);
char demux_dev[PATH_MAX];
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,
unsigned int freq, unsigned int srate, char pol, int tone,
bool is_dvb_s2, int stream_id,
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,
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) {
case TUNER_TER: {
/* 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:
if (freq < 1000000)
freq *= 1000UL;
feparams.frequency = freq;
feparams.inversion = specInv;
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;
}
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",
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;
break;
case SYS_DVBS:
case SYS_DVBS2:
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;
break;
case SYS_DVBC_ANNEX_A:
case SYS_DVBC_ANNEX_C:
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;
break;
#ifdef DVB_ATSC
case TUNER_ATSC: {
feparams.frequency = freq;
case SYS_ATSC:
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;
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 tone,
bool is_dvb_s2, int stream_id, fe_spectral_inversion_t specInv,
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,
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,
is_dvb_s2, stream_id, specInv, diseqc, modulation,
int ris = tune_it(priv, state->fe_fd, delsys, freq, srate, pol,
stream_id, specInv, diseqc, modulation,
HP_CodeRate, TransmissionMode, guardInterval,
bandWidth, LP_CodeRate, hier, timeout);

15
stream/dvb_tune.h
View File

@ -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);
int dvb_fix_demuxes(dvb_priv_t *priv, int cnt);
const char *get_dvb_delsys(unsigned int delsys);
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_demux_start(int fd);
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,
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,
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,

90
stream/dvbin.h
View File

@ -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;
bool is_dvb_s2;
int stream_id;
int service_id;
unsigned int tpid, dpid1, dpid2, progid, ca, pids[DMX_FILTER_SIZE], pids_cnt;
bool is_dvb_x2;
unsigned int delsys;
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;
uint16_t current;
unsigned int NUM_CHANNELS;
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;
dvb_card_config_t *cards;
unsigned int adapters_count;
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
#define TUNER_CBL 3
#define TUNER_ATSC 4
/* Keep in sync with enum fe_delivery_system. */
#ifndef DVB_USE_S2API
# 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 *);

763
stream/stream_dvb.c
View File

File diff suppressed because it is too large Load Diff