stv0g/tvheadend
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
tvheadend/src/input/mpegts/linuxdvb/linuxdvb_frontend.c
Adam Sutton f26ee05092 linuxdvb: updated tuning/pid filtering code 
All services/tables should now be opened using PES filters if the
tuner is not in full mux mode.
2013-06-01 23:03:17 +01:00

755 lines
21 KiB
C
Raw Blame History

/*
* Tvheadend - Linux DVB frontend
*
* Copyright (C) 2013 Adam Sutton
*
* 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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "tvheadend.h"
#include "linuxdvb_private.h"
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>
#include <linux/dvb/dmx.h>
static int
linuxdvb_frontend_tune
( linuxdvb_frontend_t *lfe, linuxdvb_mux_t *lm );
static void
linuxdvb_frontend_monitor ( void *aux );
static void *
linuxdvb_frontend_input_thread ( void *aux );
/* **************************************************************************
* Class definition
* *************************************************************************/
extern const idclass_t linuxdvb_hardware_class;
static const char *
linuxdvb_frontend_class_get_title ( idnode_t *in )
{
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)in;
if (lfe->lh_displayname)
return lfe->lh_displayname;
if (lfe->lfe_fe_path)
return lfe->lfe_fe_path;
return "unknown";
}
static void
linuxdvb_frontend_class_save ( idnode_t *in )
{
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)in;
linuxdvb_device_save((linuxdvb_device_t*)lfe->lh_parent->lh_parent);
}
const idclass_t linuxdvb_frontend_class =
{
.ic_super = &linuxdvb_hardware_class,
.ic_class = "linuxdvb_frontend",
.ic_caption = "Linux DVB Frontend",
.ic_get_title = linuxdvb_frontend_class_get_title,
.ic_save = linuxdvb_frontend_class_save,
.ic_properties = (const property_t[]) {
{ PROPDEF2("fe_path", "Frontend Path",
PT_STR, linuxdvb_frontend_t, lfe_fe_path, 1) },
{ PROPDEF2("dvr_path", "Input Path",
PT_STR, linuxdvb_frontend_t, lfe_dvr_path, 1) },
{ PROPDEF2("dmx_path", "Demux Path",
PT_STR, linuxdvb_frontend_t, lfe_dmx_path, 1) },
{ PROPDEF2("number", "FE Number",
PT_INT, linuxdvb_frontend_t, lfe_number, 1) },
{ PROPDEF1("fullmux", "Full Mux Mode",
PT_BOOL, linuxdvb_frontend_t, lfe_fullmux) },
{}
}
};
const idclass_t linuxdvb_frontend_dvbt_class =
{
.ic_super = &linuxdvb_frontend_class,
.ic_class = "linuxdvb_frontend_dvbt",
.ic_caption = "Linux DVB-T Frontend",
.ic_properties = (const property_t[]){
{}
}
};
const idclass_t linuxdvb_frontend_dvbs_class =
{
.ic_super = &linuxdvb_frontend_class,
.ic_class = "linuxdvb_frontend_dvbs",
.ic_caption = "Linux DVB-S Frontend",
.ic_properties = (const property_t[]){
{}
}
};
const idclass_t linuxdvb_frontend_dvbc_class =
{
.ic_super = &linuxdvb_frontend_class,
.ic_class = "linuxdvb_frontend_dvbc",
.ic_caption = "Linux DVB-C Frontend",
.ic_properties = (const property_t[]){
{}
}
};
const idclass_t linuxdvb_frontend_atsc_class =
{
.ic_super = &linuxdvb_frontend_class,
.ic_class = "linuxdvb_frontend_atsc",
.ic_caption = "Linux ATSC Frontend",
.ic_properties = (const property_t[]){
{}
}
};
/* **************************************************************************
* Class methods
* *************************************************************************/
static int
linuxdvb_frontend_is_enabled ( mpegts_input_t *mi )
{
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
if (lfe->lfe_fe_path == NULL) return 0;
if (!lfe->mi_enabled) return 0;
if (access(lfe->lfe_fe_path, R_OK | W_OK)) return 0;
return 1;
}
static void
linuxdvb_frontend_display_name ( mpegts_input_t* mi, char *buf, size_t len )
{
strncpy(buf, linuxdvb_frontend_class_get_title(&mi->mi_id), len);
}
#if 0
static int
linuxdvb_frontend_is_free ( mpegts_input_t *mi )
{
#if 0
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
linuxdvb_adapter_t *la = lfe->lfe_adapter;
return linuxdvb_adapter_is_free(la);
#endif
return 0;
}
static int
linuxdvb_frontend_current_weight ( mpegts_input_t *mi )
{
#if 0
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
linuxdvb_adapter_t *la = lfe->lfe_adapter;
return linuxdvb_adapter_current_weight(la);
#endif
return 0;
}
#endif
static void
linuxdvb_frontend_stop_mux
( mpegts_input_t *mi, mpegts_mux_instance_t *mmi )
{
char buf1[256], buf2[256];
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
mi->mi_display_name(mi, buf1, sizeof(buf1));
mmi->mmi_mux->mm_display_name(mmi->mmi_mux, buf2, sizeof(buf2));
tvhdebug("linuxdvb", "%s - stopping %s", buf1, buf2);
/* Stop thread */
if (lfe->lfe_dvr_pipe.wr > 0) {
tvh_write(lfe->lfe_dvr_pipe.wr, "", 1);
tvhtrace("linuxdvb", "%s - waiting for dvr thread", buf1);
pthread_join(lfe->lfe_dvr_thread, NULL);
tvh_pipe_close(&lfe->lfe_dvr_pipe);
tvhdebug("linuxdvb", "%s - stopped dvr thread", buf1);
}
/* Not locked */
lfe->lfe_locked = 0;
}
static int
linuxdvb_frontend_start_mux
( mpegts_input_t *mi, mpegts_mux_instance_t *mmi )
{
int r;
char buf1[256], buf2[256];
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
mpegts_mux_instance_t *cur = LIST_FIRST(&mi->mi_mux_active);
mi->mi_display_name(mi, buf1, sizeof(buf1));
mmi->mmi_mux->mm_display_name(mmi->mmi_mux, buf2, sizeof(buf2));
tvhdebug("linuxdvb", "%s - starting %s", buf1, buf2);
// Not sure if this is right place?
/* Currently active */
if (cur != NULL) {
/* Already tuned */
if (mmi == cur)
return 0;
/* Stop current */
cur->mmi_mux->mm_stop(cur->mmi_mux);
}
assert(LIST_FIRST(&mi->mi_mux_active) == NULL);
/* Open FE */
if (lfe->lfe_fe_fd <= 0) {
tvhtrace("linuxdvb", "%s - opening FE %s", buf1, lfe->lfe_fe_path);
lfe->lfe_fe_fd = tvh_open(lfe->lfe_fe_path, O_RDWR | O_NONBLOCK, 0);
if (lfe->lfe_fe_fd <= 0) {
return SM_CODE_TUNING_FAILED;
}
}
/* Tune */
tvhtrace("linuxdvb", "%s - tuning", buf1);
r = linuxdvb_frontend_tune(lfe, (linuxdvb_mux_t*)mmi->mmi_mux);
/* Failed */
if (r != 0) {
tvherror("linuxdvb", "%s - failed to tune [e=%s]", buf1, strerror(errno));
if (errno == EINVAL)
mmi->mmi_tune_failed = 1;
return SM_CODE_TUNING_FAILED;
}
/* Start monitor */
time(&lfe->lfe_monitor);
lfe->lfe_monitor += 4;
gtimer_arm_ms(&lfe->lfe_monitor_timer, linuxdvb_frontend_monitor, lfe, 50);
return r;
}
static int
linuxdvb_frontend_open_pid
( linuxdvb_frontend_t *lfe, int pid, const char *name )
{
char buf[256];
struct dmx_pes_filter_params dmx_param;
int fd = tvh_open(lfe->lfe_dmx_path, O_RDWR, 0);
if (!name) {
lfe->mi_display_name((mpegts_input_t*)lfe, buf, sizeof(buf));
name = buf;
}
if(fd == -1) {
tvherror("linuxdvb", "%s - failed to open dmx for pid %d [e=%s]",
name, pid, strerror(errno));
return -1;
}
memset(&dmx_param, 0, sizeof(dmx_param));
dmx_param.pid = pid;
dmx_param.input = DMX_IN_FRONTEND;
dmx_param.output = DMX_OUT_TS_TAP;
dmx_param.pes_type = DMX_PES_OTHER;
dmx_param.flags = DMX_IMMEDIATE_START;
if(ioctl(fd, DMX_SET_PES_FILTER, &dmx_param)) {
tvherror("linuxdvb", "%s - failed to config dmx for pid %d [e=%s]",
name, pid, strerror(errno));
close(fd);
return -1;
}
return fd;
}
static void
linuxdvb_frontend_open_service
( mpegts_input_t *mi, mpegts_service_t *s )
{
char buf[256];
elementary_stream_t *st;
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
/* Ignore in full rx mode OR if not yet locked */
if (lfe->lfe_fullmux || !lfe->lfe_locked)
return;
mi->mi_display_name(mi, buf, sizeof(buf));
/* Install PES filters */
TAILQ_FOREACH(st, &s->s_components, es_link) {
if(st->es_pid >= 0x2000)
continue;
if(st->es_demuxer_fd != -1)
continue;
st->es_cc_valid = 0;
st->es_demuxer_fd
= linuxdvb_frontend_open_pid((linuxdvb_frontend_t*)mi, st->es_pid, buf);
}
}
static void
linuxdvb_frontend_close_service
( mpegts_input_t *mi, mpegts_service_t *s )
{
linuxdvb_frontend_t *lfe = (linuxdvb_frontend_t*)mi;
/* Ignore in full rx mode OR if not yet locked */
if (lfe->lfe_fullmux || !lfe->lfe_locked)
return;
}
/* **************************************************************************
* Data processing
* *************************************************************************/
static void
linuxdvb_frontend_default_tables
( linuxdvb_frontend_t *lfe, linuxdvb_mux_t *lm )
{
mpegts_mux_t *mm = (mpegts_mux_t*)lfe;
/* Common */
mpegts_table_add(mm, DVB_PAT_BASE, DVB_PAT_MASK, dvb_pat_callback,
NULL, "pat", MT_QUICKREQ | MT_CRC, DVB_PAT_PID);
#if 0
mpegts_table_add(mm, DVB_CAT_BASE, DVB_CAT_MASK, dvb_cat_callback,
NULL, "cat", MT_CRC, DVB_CAT_PID);
#endif
/* ATSC */
if (lfe->lfe_info.type == FE_ATSC) {
#if 0
int tableid;
if (lc->lm_tuning.dmc_fe_params.u.vsb.modulation == VSB_8)
tableid = ATSC_VCT_TERR;
else
tableid = ATSC_VCT_CAB;
mpegts_table_add(mm, tableid, 0xff, atsc_vct_callback,
NULL, "vct", MT_QUICKREQ | MT_CRC, ATSC_VCT_PID);
#endif
/* DVB */
} else {
mpegts_table_add(mm, DVB_NIT_BASE, DVB_NIT_MASK, dvb_nit_callback,
NULL, "nit", MT_QUICKREQ | MT_CRC, DVB_NIT_PID);
mpegts_table_add(mm, DVB_SDT_BASE, DVB_SDT_MASK, dvb_sdt_callback,
NULL, "sdt", MT_QUICKREQ | MT_CRC, DVB_SDT_PID);
mpegts_table_add(mm, DVB_BAT_BASE, DVB_BAT_MASK, dvb_bat_callback,
NULL, "bat", MT_CRC, DVB_BAT_PID);
#if 0
mpegts_table_add(mm, DVB_TOT_BASE, DVB_TOT_MASK, dvb_tot_callback,
NULL, "tot", MT_CRC, DVB_TOT_PID);
#endif
}
}
static void
linuxdvb_frontend_open_services ( linuxdvb_frontend_t *lfe )
{
service_t *s;
LIST_FOREACH(s, &lfe->mi_transports, s_active_link)
linuxdvb_frontend_open_service((mpegts_input_t*)lfe,
(mpegts_service_t*)s);
}
static void
linuxdvb_frontend_monitor_stats ( linuxdvb_frontend_t *lfe )
{
}
static void
linuxdvb_frontend_monitor ( void *aux )
{
linuxdvb_frontend_t *lfe = aux;
mpegts_mux_instance_t *mmi = LIST_FIRST(&lfe->mi_mux_active);
mpegts_mux_t *mm;
fe_status_t fe_status;
signal_state_t status;
// TODO: check the frontend is accessible
if (!mmi) return;
mm = mmi->mmi_mux;
/* Get current status */
if (!ioctl(lfe->lfe_fe_fd, FE_READ_STATUS, &fe_status))
status = SIGNAL_UNKNOWN;
else if (fe_status & FE_HAS_LOCK)
status = SIGNAL_GOOD;
else if (fe_status & (FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_CARRIER))
status = SIGNAL_BAD;
else if (fe_status & FE_HAS_SIGNAL)
status = SIGNAL_FAINT;
else
status = SIGNAL_NONE;
/* Set default period */
gtimer_arm(&lfe->lfe_monitor_timer, linuxdvb_frontend_monitor, lfe, 1);
/* Waiting for lock */
if (lfe->lfe_locked) {
/* Locked */
if (status == SIGNAL_GOOD) {
lfe->lfe_locked = 1;
/* Start input */
tvh_pipe(O_NONBLOCK, &lfe->lfe_dvr_pipe);
pthread_create(&lfe->lfe_dvr_thread, NULL,
linuxdvb_frontend_input_thread, lfe);
/* Table handlers */
linuxdvb_frontend_default_tables(lfe, (linuxdvb_mux_t*)mm);
/* Services */
linuxdvb_frontend_open_services(lfe);
/* Re-arm (quick) */
} else {
gtimer_arm_ms(&lfe->lfe_monitor_timer, linuxdvb_frontend_monitor,
lfe, 50);
/* Monitor 1 per sec */
if (dispatch_clock < lfe->lfe_monitor)
return;
lfe->lfe_monitor = dispatch_clock + 1;
}
}
/* Monitor stats */
linuxdvb_frontend_monitor_stats(lfe);
}
static void *
linuxdvb_frontend_input_thread ( void *aux )
{
linuxdvb_frontend_t *lfe = aux;
mpegts_mux_instance_t *mmi;
int dmx = -1, dvr = -1;
char buf[256];
uint8_t tsb[18800];
int pos = 0, nfds, efd;
ssize_t c;
struct epoll_event ev;
struct dmx_pes_filter_params dmx_param;
int fullmux;
/* Get MMI */
pthread_mutex_lock(&global_lock);
lfe->mi_display_name((mpegts_input_t*)lfe, buf, sizeof(buf));
mmi = LIST_FIRST(&lfe->mi_mux_active);
fullmux = lfe->lfe_fullmux;
pthread_mutex_unlock(&global_lock);
if (mmi == NULL) return NULL;
/* Open DMX */
if (fullmux) {
dmx = tvh_open(lfe->lfe_dmx_path, O_RDWR, 0);
if (dmx < 0) {
tvherror("linuxdvb", "%s - failed to open %s", buf, lfe->lfe_dmx_path);
return NULL;
}
memset(&dmx_param, 0, sizeof(dmx_param));
dmx_param.pid = 0x2000;
dmx_param.input = DMX_IN_FRONTEND;
dmx_param.output = DMX_OUT_TS_TAP;
dmx_param.pes_type = DMX_PES_OTHER;
dmx_param.flags = DMX_IMMEDIATE_START;
if(ioctl(dmx, DMX_SET_PES_FILTER, &dmx_param) == -1) {
tvherror("linuxdvb", "%s - open raw filter failed [e=%s]",
buf, strerror(errno));
close(dmx);
return NULL;
}
}
/* Open DVR */
dvr = tvh_open(lfe->lfe_dvr_path, O_RDONLY | O_NONBLOCK, 0);
if (dvr < 0) {
close(dmx);
tvherror("linuxdvb", "%s - failed to open %s", buf, lfe->lfe_dvr_path);
return NULL;
}
/* Setup poll */
efd = epoll_create(2);
memset(&ev, 0, sizeof(ev));
ev.events = EPOLLIN;
ev.data.fd = dvr;
epoll_ctl(efd, EPOLL_CTL_ADD, ev.data.fd, &ev);
ev.events = EPOLLIN;
ev.data.fd = lfe->lfe_dvr_pipe.rd;
epoll_ctl(efd, EPOLL_CTL_ADD, ev.data.fd, &ev);
/* Read */
while (1) {
nfds = epoll_wait(efd, &ev, 1, 10);
if (nfds < 1) continue;
if (ev.data.fd != dvr) break;
/* Read */
c = read(dvr, tsb+pos, sizeof(tsb)-pos);
if (c < 0) {
if ((errno == EAGAIN) || (errno == EINTR))
continue;
if (errno == EOVERFLOW) {
tvhlog(LOG_WARNING, "linuxdvb", "%s - read() EOVERFLOW", buf);
continue;
}
tvhlog(LOG_ERR, "linuxdvb", "%s - read() error %d (%s)",
buf, errno, strerror(errno));
break;
}
/* Process */
pos = mpegts_input_recv_packets((mpegts_input_t*)lfe, mmi, tsb, c,
NULL, NULL, buf);
}
if (dmx != -1) close(dmx);
close(dvr);
return NULL;
}
/* **************************************************************************
* Tuning
* *************************************************************************/
static int
linuxdvb_frontend_tune
( linuxdvb_frontend_t *lfe, linuxdvb_mux_t *lm )
{
int r;
struct dvb_frontend_event ev;
dvb_mux_conf_t *dmc = &lm->lm_tuning;
struct dvb_frontend_parameters *p = &dmc->dmc_fe_params;
/* S2 tuning */
#if DVB_API_VERSION >= 5
struct dtv_property cmds[20];
struct dtv_properties cmdseq = { .num = 0, .props = cmds };
/* Clear Q */
static struct dtv_property clear_p[] = {
{ .cmd = DTV_CLEAR },
};
static struct dtv_properties clear_cmdseq = {
.num = 1,
.props = clear_p
};
if ((ioctl(lfe->lfe_fe_fd, FE_SET_PROPERTY, &clear_cmdseq)) != 0)
return -1;
/* Tune */
#define S2CMD(c, d)\
cmds[cmdseq.num].cmd = c;\
cmds[cmdseq.num++].u.data = d
S2CMD(DTV_DELIVERY_SYSTEM, lm->lm_tuning.dmc_fe_delsys);
S2CMD(DTV_FREQUENCY, p->frequency);
S2CMD(DTV_INVERSION, p->inversion);
/* DVB-T */
if (lfe->lfe_info.type == FE_OFDM) {
S2CMD(DTV_BANDWIDTH_HZ, dvb_bandwidth(p->u.ofdm.bandwidth));
S2CMD(DTV_CODE_RATE_HP, p->u.ofdm.code_rate_HP);
S2CMD(DTV_CODE_RATE_LP, p->u.ofdm.code_rate_LP);
S2CMD(DTV_MODULATION, p->u.ofdm.constellation);
S2CMD(DTV_TRANSMISSION_MODE, p->u.ofdm.transmission_mode);
S2CMD(DTV_GUARD_INTERVAL, p->u.ofdm.guard_interval);
S2CMD(DTV_HIERARCHY, p->u.ofdm.hierarchy_information);
/* DVB-C */
} else if (lfe->lfe_info.type == FE_QAM) {
S2CMD(DTV_SYMBOL_RATE, p->u.qam.symbol_rate);
S2CMD(DTV_MODULATION, p->u.qam.modulation);
S2CMD(DTV_INNER_FEC, p->u.qam.fec_inner);
/* DVB-S */
} else if (lfe->lfe_info.type == FE_QPSK) {
S2CMD(DTV_SYMBOL_RATE, p->u.qpsk.symbol_rate);
S2CMD(DTV_INNER_FEC, p->u.qpsk.fec_inner);
S2CMD(DTV_MODULATION, dmc->dmc_fe_modulation);
S2CMD(DTV_ROLLOFF, dmc->dmc_fe_rolloff);
/* ATSC */
} else {
S2CMD(DTV_MODULATION, p->u.vsb.modulation);
}
/* Tune */
S2CMD(DTV_TUNE, 0);
#undef S2CMD
#endif
/* discard stale events */
while (1) {
if (ioctl(lfe->lfe_fe_fd, FE_GET_EVENT, &ev) == -1)
break;
}
/* S2 tuning */
#if DVB_API_VERSION >= 5
r = ioctl(lfe->lfe_fe_fd, FE_SET_PROPERTY, &cmdseq);
/* v3 tuning */
#else
r = ioctl(lfe->lfe_fe_fd, FE_SET_FRONTEND, p);
#endif
return r;
}
/* **************************************************************************
* Creation/Config
* *************************************************************************/
linuxdvb_frontend_t *
linuxdvb_frontend_create0
( linuxdvb_adapter_t *la, const char *uuid, htsmsg_t *conf, fe_type_t type )
{
const char *str;
const idclass_t *idc;
pthread_t tid;
/* Get type */
if (conf) {
if (!(str = htsmsg_get_str(conf, "type")))
return NULL;
type = dvb_str2type(str);
}
/* Class */
if (type == FE_QPSK)
idc = &linuxdvb_frontend_dvbs_class;
else if (type == FE_QAM)
idc = &linuxdvb_frontend_dvbc_class;
else if (type == FE_OFDM)
idc = &linuxdvb_frontend_dvbt_class;
else if (type == FE_ATSC)
idc = &linuxdvb_frontend_atsc_class;
else {
tvherror("linuxdvb", "unknown FE type %d", type);
return NULL;
}
linuxdvb_frontend_t *lfe
= (linuxdvb_frontend_t*)
mpegts_input_create0(calloc(1, sizeof(linuxdvb_frontend_t)),
idc, uuid, conf);
lfe->lfe_info.type = type;
/* Input callbacks */
lfe->mi_is_enabled = linuxdvb_frontend_is_enabled;
lfe->mi_display_name = linuxdvb_frontend_display_name;
lfe->mi_start_mux = linuxdvb_frontend_start_mux;
lfe->mi_stop_mux = linuxdvb_frontend_stop_mux;
lfe->mi_open_service = linuxdvb_frontend_open_service;
lfe->mi_close_service = linuxdvb_frontend_close_service;
lfe->lfe_open_pid = linuxdvb_frontend_open_pid;
/* Adapter link */
lfe->lh_parent = (linuxdvb_hardware_t*)la;
LIST_INSERT_HEAD(&la->lh_children, (linuxdvb_hardware_t*)lfe, lh_parent_link);
/* Start table thread */
pthread_create(&tid, NULL, mpegts_input_table_thread, lfe);
/* No conf */
if (!conf)
return lfe;
/* TODO: this should be done differently */
if ((str = htsmsg_get_str(conf, "network"))) {
linuxdvb_network_t *ln = linuxdvb_network_find_by_uuid(str);
if (ln) {
if (ln->ln_type == lfe->lfe_info.type) {
mpegts_network_add_input((mpegts_network_t*)ln, (mpegts_input_t*)lfe);
} else
tvhlog(LOG_WARNING, "linuxdvb",
"attempt to add network %s of wrong type %s to %s (%s)",
dvb_type2str(ln->ln_type), ln->mn_network_name,
lfe->lh_displayname, dvb_type2str(lfe->lfe_info.type));
}
}
return lfe;
}
linuxdvb_frontend_t *
linuxdvb_frontend_added
( linuxdvb_adapter_t *la, int fe_num,
const char *fe_path,
const char *dmx_path,
const char *dvr_path,
const struct dvb_frontend_info *fe_info )
{
linuxdvb_hardware_t *lh;
linuxdvb_frontend_t *lfe = NULL;
/* Find existing */
LIST_FOREACH(lh, &la->lh_children, lh_parent_link) {
lfe = (linuxdvb_frontend_t*)lh;
if (lfe->lfe_number == fe_num) {
if (lfe->lfe_info.type != fe_info->type) {
tvhlog(LOG_ERR, "linuxdvb", "detected incorrect fe_type %s != %s",
dvb_type2str(lfe->lfe_info.type), dvb_type2str(fe_info->type));
return NULL;
}
break;
}
}
/* Create new */
if (!lfe) {
if (!(lfe = linuxdvb_frontend_create0(la, NULL, NULL, fe_info->type))) {
tvhlog(LOG_ERR, "linuxdvb", "failed to create frontend");
return NULL;
}
}
/* Copy info */
lfe->lfe_number = fe_num;
memcpy(&lfe->lfe_info, fe_info, sizeof(struct dvb_frontend_info));
/* Set paths */
lfe->lfe_fe_path = strdup(fe_path);
lfe->lfe_dmx_path = strdup(dmx_path);
lfe->lfe_dvr_path = strdup(dvr_path);
return lfe;
}
void
linuxdvb_frontend_save ( linuxdvb_frontend_t *lfe, htsmsg_t *m )
{
mpegts_input_save((mpegts_input_t*)lfe, m);
htsmsg_add_str(m, "type", dvb_type2str(lfe->lfe_info.type));
}
/******************************************************************************
* Editor Configuration
*
* vim:sts=2:ts=2:sw=2:et
*****************************************************************************/
Reference in a new issue View git blame Copy permalink