stv0g/tvheadend
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Move some table stuff over to dvb_mux_t

Browse source
This commit is contained in:
Andreas Öman 2012-12-05 12:03:58 +01:00
parent e9604bd9de
commit 8681d71857
12 changed files with 220 additions and 206 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
src/dvb/dvb.h
View file

@ -93,11 +93,11 @@ typedef struct dvb_network {
struct th_dvb_mux_instance_queue dn_initial_scan_queue;
int dn_initial_num_mux;
struct th_dvb_mux_instance *dn_mux_epg;
struct dvb_mux *dn_mux_epg;
int dn_fe_type; // Frontend types for this network (FE_QPSK, etc)
// struct dvb_mux_list dn_muxes;
struct dvb_mux_list dn_muxes;
} dvb_network_t;
@ -108,7 +108,7 @@ typedef struct dvb_network {
*/
typedef struct dvb_mux {
// LIST_ENTRY(dvb_mux) dm_network_link;
LIST_ENTRY(dvb_mux) dm_network_link;
dvb_network_t *dm_dn;
struct service_list dm_services;
@ -120,6 +120,10 @@ typedef struct dvb_mux {
char *dm_network_name; /* Name of network, from NIT table */
char *dm_default_authority;
TAILQ_HEAD(, epggrab_ota_mux) dm_epg_grab;
struct th_dvb_mux_instance *dm_tdmi; // wrong
} dvb_mux_t;
@ -172,8 +176,6 @@ typedef struct th_dvb_mux_instance {
TAILQ_ENTRY(th_dvb_mux_instance) tdmi_scan_link;
struct th_dvb_mux_instance_queue *tdmi_scan_queue;
TAILQ_HEAD(, epggrab_ota_mux) tdmi_epg_grab;
struct th_subscription_list tdmi_subscriptions;
} th_dvb_mux_instance_t;
@ -314,7 +316,7 @@ typedef struct th_dvb_table {
char *tdt_name;
void *tdt_opaque;
int (*tdt_callback)(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
int (*tdt_callback)(dvb_mux_t *dm, uint8_t *buf, int len,
uint8_t tableid, void *opaque);
@ -426,11 +428,11 @@ th_dvb_mux_instance_t *dvb_mux_create(th_dvb_adapter_t *tda,
const char *logprefix, int enabled,
int initialscan, const char *identifier);
void dvb_mux_set_networkname(th_dvb_mux_instance_t *tdmi, const char *name);
void dvb_mux_set_networkname(dvb_mux_t *dm, const char *name);
void dvb_mux_set_tsid(th_dvb_mux_instance_t *tdmi, uint16_t tsid);
void dvb_mux_set_tsid(dvb_mux_t *dm, uint16_t tsid);
void dvb_mux_set_onid(th_dvb_mux_instance_t *tdmi, uint16_t onid);
void dvb_mux_set_onid(dvb_mux_t *mux, uint16_t onid);
void dvb_mux_set_enable(th_dvb_mux_instance_t *tdmi, int enabled);
@ -501,22 +503,21 @@ void dvb_fe_stop(th_dvb_mux_instance_t *tdmi, int retune);
*/
void dvb_table_init(th_dvb_adapter_t *tda);
void dvb_table_add_default(th_dvb_mux_instance_t *tdmi);
void dvb_table_add_default(dvb_mux_t *dm);
void dvb_table_flush_all(th_dvb_mux_instance_t *tdmi);
void dvb_table_add_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid);
void dvb_table_add_pmt(dvb_mux_t *dm, int pmt_pid);
void dvb_table_rem_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid);
void dvb_table_rem_pmt(dvb_mux_t *dm, int pmt_pid);
void tdt_add(th_dvb_mux_instance_t *tdmi, int table, int mask,
int (*callback)(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
void tdt_add(dvb_mux_t *dm, int table, int mask,
int (*callback)(dvb_mux_t *dm, uint8_t *buf, int len,
uint8_t tableid, void *opaque), void *opaque,
const char *name, int flags, int pid);
int dvb_pidx11_callback
(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t tableid, void *opaque);
int dvb_pidx11_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque);
#define TDT_CRC 0x1
#define TDT_QUICKREQ 0x2

2
src/dvb/dvb_adapter.c
View file

@ -748,7 +748,7 @@ dvb_adapter_mux_scanner(void *aux)
if (period > 20)
gtimer_arm(&tda->tda_mux_scanner_timer,
dvb_adapter_mux_scanner, tda, period);
dvb_fe_tune(tda->tda_dn->dn_mux_epg, "EPG scan");
dvb_fe_tune(tda->tda_dn->dn_mux_epg->dm_tdmi, "EPG scan");
return;
}

6
src/dvb/dvb_fe.c
View file

@ -277,7 +277,7 @@ dvb_fe_stop(th_dvb_mux_instance_t *tdmi, int retune)
assert(tdmi->tdmi_scan_queue == NULL);
epggrab_mux_stop(tdmi, 0);
epggrab_mux_stop(tdmi->tdmi_mux, 0);
if (!retune) {
gtimer_disarm(&tda->tda_fe_monitor_timer);
@ -512,8 +512,8 @@ dvb_fe_tune(th_dvb_mux_instance_t *tdmi, const char *reason)
gtimer_arm(&tda->tda_fe_monitor_timer, dvb_fe_monitor, tda, 1);
dvb_table_add_default(tdmi);
epggrab_mux_start(tdmi);
dvb_table_add_default(tdmi->tdmi_mux);
epggrab_mux_start(tdmi->tdmi_mux);
dvb_adapter_notify(tda);
return 0;

33
src/dvb/dvb_multiplex.c
View file

@ -228,11 +228,14 @@ dvb_mux_create(th_dvb_adapter_t *tda, const struct dvb_mux_conf *dmc,
dm->dm_network_id = onid;
dm->dm_transport_stream_id = tsid;
dm->dm_network_name = network ? strdup(network) : NULL;
dm->dm_dn = tda->tda_dn;
TAILQ_INIT(&dm->dm_epg_grab);
dm->dm_dn = tda->tda_dn;
LIST_INSERT_HEAD(&tda->tda_dn->dn_muxes, dm, dm_network_link);
tdmi = calloc(1, sizeof(th_dvb_mux_instance_t));
tdmi->tdmi_mux = dm;
dm->dm_tdmi = tdmi;
if(identifier == NULL) {
char qpsktxt[20];
@ -263,7 +266,6 @@ dvb_mux_create(th_dvb_adapter_t *tda, const struct dvb_mux_conf *dmc,
return NULL;
}
TAILQ_INIT(&tdmi->tdmi_epg_grab);
tdmi->tdmi_enabled = enabled;
@ -332,7 +334,7 @@ dvb_mux_destroy(th_dvb_mux_instance_t *tdmi)
if(tdmi->tdmi_table_initial)
tda->tda_dn->dn_initial_num_mux--;
epggrab_mux_delete(tdmi);
epggrab_mux_delete(tdmi->tdmi_mux); // XXX(dvbreorg)
hts_settings_remove("dvbmuxes/%s", tdmi->tdmi_identifier);
@ -810,12 +812,15 @@ dvb_mux_load(th_dvb_adapter_t *tda)
*
*/
void
dvb_mux_set_networkname(th_dvb_mux_instance_t *tdmi, const char *networkname)
dvb_mux_set_networkname(dvb_mux_t *dm, const char *networkname)
{
htsmsg_t *m;
free(tdmi->tdmi_mux->dm_network_name);
tdmi->tdmi_mux->dm_network_name = strdup(networkname);
free(dm->dm_network_name);
dm->dm_network_name = strdup(networkname);
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
dvb_mux_save(tdmi);
m = htsmsg_create_map();
@ -829,12 +834,14 @@ dvb_mux_set_networkname(th_dvb_mux_instance_t *tdmi, const char *networkname)
*
*/
void
dvb_mux_set_tsid(th_dvb_mux_instance_t *tdmi, uint16_t tsid)
dvb_mux_set_tsid(dvb_mux_t *dm, uint16_t tsid)
{
htsmsg_t *m;
tdmi->tdmi_mux->dm_transport_stream_id = tsid;
dm->dm_transport_stream_id = tsid;
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
dvb_mux_save(tdmi);
m = htsmsg_create_map();
@ -847,12 +854,14 @@ dvb_mux_set_tsid(th_dvb_mux_instance_t *tdmi, uint16_t tsid)
*
*/
void
dvb_mux_set_onid(th_dvb_mux_instance_t *tdmi, uint16_t onid)
dvb_mux_set_onid(dvb_mux_t *dm, uint16_t onid)
{
htsmsg_t *m;
tdmi->tdmi_mux->dm_network_id = onid;
dm->dm_network_id = onid;
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
dvb_mux_save(tdmi);
m = htsmsg_create_map();

2
src/dvb/dvb_service.c
View file

@ -97,7 +97,7 @@ dvb_service_start(service_t *t, unsigned int weight, int force_start)
if(!r)
tda->tda_open_service(tda, t);
dvb_table_add_pmt(t->s_dvb_mux_instance, t->s_pmt_pid);
dvb_table_add_pmt(t->s_dvb_mux_instance->tdmi_mux, t->s_pmt_pid);
return r;
}

198
src/dvb/dvb_tables.c
View file

@ -86,6 +86,7 @@ dvb_table_dispatch(uint8_t *sec, int r, th_dvb_table_t *tdt)
uint8_t *ptr;
int ret;
th_dvb_mux_instance_t *tdmi = tdt->tdt_tdmi;
dvb_mux_t *dm = tdmi->tdmi_mux;
/* It seems some hardware (or is it the dvb API?) does not
honour the DMX_CHECK_CRC flag, so we check it again */
@ -106,12 +107,12 @@ dvb_table_dispatch(uint8_t *sec, int r, th_dvb_table_t *tdt)
if(chkcrc) len -= 4; /* Strip trailing CRC */
if(tdt->tdt_flags & TDT_CA)
ret = tdt->tdt_callback((th_dvb_mux_instance_t *)tdt,
sec, len + 3, tableid, tdt->tdt_opaque);
ret = tdt->tdt_callback((dvb_mux_t *)tdt,
sec, len + 3, tableid, tdt->tdt_opaque);
else if(tdt->tdt_flags & TDT_TDT)
ret = tdt->tdt_callback(tdt->tdt_tdmi, ptr, len, tableid, tdt);
ret = tdt->tdt_callback(dm, ptr, len, tableid, tdt);
else
ret = tdt->tdt_callback(tdt->tdt_tdmi, ptr, len, tableid, tdt->tdt_opaque);
ret = tdt->tdt_callback(dm, ptr, len, tableid, tdt->tdt_opaque);
if(ret == 0)
tdt->tdt_count++;
@ -154,12 +155,13 @@ dvb_tdt_destroy(th_dvb_adapter_t *tda, th_dvb_mux_instance_t *tdmi,
* Add a new DVB table
*/
void
tdt_add(th_dvb_mux_instance_t *tdmi, int tableid, int mask,
int (*callback)(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
tdt_add(dvb_mux_t *dm, int tableid, int mask,
int (*callback)(dvb_mux_t *dm, uint8_t *buf, int len,
uint8_t tableid, void *opaque), void *opaque,
const char *name, int flags, int pid)
{
th_dvb_table_t *t;
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
// Allow multiple entries per PID, but only one per callback/opaque instance
// TODO: this could mean reading the same data multiple times, and not
@ -230,14 +232,14 @@ dvb_desc_def_authority(uint8_t *ptr, int len, char *defauth, size_t dalen)
}
static int
dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
dvb_bat_callback(dvb_mux_t *dm, uint8_t *buf, int len,
uint8_t tableid, void *opaque)
{
int i, j, bdlen, tslen, tdlen;
uint8_t dtag, dlen;
uint16_t tsid, onid;
char crid[257];
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
dvb_network_t *dn = dm->dm_dn;
if (tableid != 0x4a) return -1;
bdlen = ((buf[5] & 0xf) << 8) | buf[6];
@ -266,14 +268,13 @@ dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
i += 6;
j = 0;
/* Find TDMI */
LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
tdmi->tdmi_mux->dm_network_id == onid)
/* Find mux */
LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
if(dm->dm_transport_stream_id == tsid && dm->dm_network_id == onid)
break;
/* Descriptors */
if (tdmi) {
if (dm != NULL) {
int save = 0;
*crid = 0;
while (j+2 < tdlen) {
@ -288,13 +289,13 @@ dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
}
j += dlen;
}
if (*crid && strcmp(tdmi->tdmi_mux->dm_default_authority ?: "", crid)) {
free(tdmi->tdmi_mux->dm_default_authority);
tdmi->tdmi_mux->dm_default_authority = strdup(crid);
if (*crid && strcmp(dm->dm_default_authority ?: "", crid)) {
free(dm->dm_default_authority);
dm->dm_default_authority = strdup(crid);
save = 1;
}
if (save)
dvb_mux_save(tdmi);
dvb_mux_save(dm->dm_tdmi);
}
i += tdlen;
@ -307,7 +308,7 @@ dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
* DVB SDT (Service Description Table)
*/
static int
dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_sdt_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
service_t *t;
@ -323,7 +324,7 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t stype;
int l;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
dvb_network_t *dn = dm->dm_dn;
if (tableid != 0x42 && tableid != 0x46) return -1;
@ -332,16 +333,16 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
tsid = ptr[0] << 8 | ptr[1];
onid = ptr[5] << 8 | ptr[6];
if (tableid == 0x42) {
if(tdmi->tdmi_mux->dm_transport_stream_id != tsid)
if(dm->dm_transport_stream_id != tsid)
return -1;
if(!tdmi->tdmi_mux->dm_network_id)
dvb_mux_set_onid(tdmi, onid);
if(!dm->dm_network_id)
dvb_mux_set_onid(dm, onid);
} else {
LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
tdmi->tdmi_mux->dm_network_id != onid)
LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
if(dm->dm_transport_stream_id == tsid &&
dm->dm_network_id != onid)
break;
if (!tdmi) return 0;
if (!dm) return 0;
}
// version = ptr[2] >> 1 & 0x1f;
@ -373,7 +374,7 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
if(dllen > len)
break;
if (!(t = dvb_service_find(tdmi, service_id, 0, NULL))) {
if (!(t = dvb_service_find(dm->dm_tdmi, service_id, 0, NULL))) {
len -= dllen;
ptr += dllen;
continue;
@ -460,14 +461,14 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
/*
* Combined PID 0x11 callback, for stuff commonly found on that PID
*/
int dvb_pidx11_callback
(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
int
dvb_pidx11_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
if (tableid == 0x42 || tableid == 0x46)
return dvb_sdt_callback(tdmi, ptr, len, tableid, opaque);
return dvb_sdt_callback(dm, ptr, len, tableid, opaque);
else if (tableid == 0x4a)
return dvb_bat_callback(tdmi, ptr, len, tableid, opaque);
return dvb_bat_callback(dm, ptr, len, tableid, opaque);
return -1;
}
@ -475,11 +476,11 @@ int dvb_pidx11_callback
* PAT - Program Allocation table
*/
static int
dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_pat_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
th_dvb_mux_instance_t *other;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
dvb_mux_t *other;
dvb_network_t *dn = dm->dm_dn;
uint16_t service, pmt, tsid;
if(len < 5)
@ -495,15 +496,15 @@ dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
// Make sure this TSID is not already known on another mux
// That might indicate that we have accedentally received a PAT
// from another mux
LIST_FOREACH(other, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
if(other != tdmi &&
other->tdmi_mux->dm_transport_stream_id == tsid &&
other->tdmi_mux->dm_network_id == tdmi->tdmi_mux->dm_network_id)
LIST_FOREACH(other, &dn->dn_muxes, dm_network_link)
if(other != dm &&
other->dm_transport_stream_id == tsid &&
other->dm_network_id == dm->dm_network_id)
return -1;
if(tdmi->tdmi_mux->dm_transport_stream_id == 0xffff)
dvb_mux_set_tsid(tdmi, tsid);
else if (tdmi->tdmi_mux->dm_transport_stream_id != tsid)
if(dm->dm_transport_stream_id == 0xffff)
dvb_mux_set_tsid(dm, tsid);
else if (dm->dm_transport_stream_id != tsid)
return -1; // TSID mismatches, skip packet, may be from another mux
ptr += 5;
@ -515,9 +516,9 @@ dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
if(service != 0 && pmt != 0) {
int save = 0;
dvb_service_find2(tdmi, service, pmt, NULL, &save);
if (save || !tda->tda_disable_pmt_monitor)
dvb_table_add_pmt(tdmi, pmt);
dvb_service_find2(dm->dm_tdmi, service, pmt, NULL, &save);
if (save || ! dm->dm_tdmi->tdmi_adapter->tda_disable_pmt_monitor)
dvb_table_add_pmt(dm, pmt);
}
ptr += 4;
len -= 4;
@ -530,10 +531,10 @@ dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* CA - Conditional Access
*/
static int
dvb_ca_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_ca_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
cwc_emm(ptr, len, (uintptr_t)opaque, (void *)tdmi);
cwc_emm(ptr, len, (uintptr_t)opaque, (void *)dm);
return 0;
}
@ -541,8 +542,8 @@ dvb_ca_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* CAT - Conditional Access Table
*/
static int
dvb_cat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
dvb_cat_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
int tag, tlen;
uint16_t pid;
@ -568,7 +569,7 @@ dvb_cat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
if(pid == 0)
break;
tdt_add(tdmi, 0, 0, dvb_ca_callback, (void *)caid, "CA",
tdt_add(dm, 0, 0, dvb_ca_callback, (void *)caid, "CA",
TDT_CA, pid);
break;
@ -613,13 +614,13 @@ static const fe_modulation_t qam_tab [6] = {
* Cable delivery descriptor
*/
static int
dvb_table_cable_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_table_cable_delivery(dvb_mux_t *dm, uint8_t *ptr, int len,
uint16_t tsid, uint16_t onid)
{
struct dvb_mux_conf dmc;
int freq, symrate;
if(!tdmi->tdmi_adapter->tda_autodiscovery)
if(!dm->dm_tdmi->tdmi_adapter->tda_autodiscovery)
return -1;
if(len < 11)
@ -651,7 +652,7 @@ dvb_table_cable_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dmc.dmc_fe_params.u.qam.fec_inner = fec_tab[ptr[10] & 0x07];
dvb_mux_create(tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
dvb_mux_create(dm->dm_tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
"automatic mux discovery", 1, 1, NULL);
return 0;
}
@ -660,14 +661,14 @@ dvb_table_cable_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* Satellite delivery descriptor
*/
static int
dvb_table_sat_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_table_sat_delivery(dvb_mux_t *dm, uint8_t *ptr, int len,
uint16_t tsid, uint16_t onid)
{
int freq, symrate;
// uint16_t orbital_pos;
struct dvb_mux_conf dmc;
if(!tdmi->tdmi_adapter->tda_autodiscovery)
if(!dm->dm_tdmi->tdmi_adapter->tda_autodiscovery)
return -1;
if(len < 11)
@ -734,7 +735,7 @@ dvb_table_sat_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
}
#endif
dvb_mux_create(tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
dvb_mux_create(dm->dm_tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
"automatic mux discovery", 1, 1, NULL);
return 0;
}
@ -744,19 +745,18 @@ dvb_table_sat_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
*
*/
static void
dvb_table_local_channel(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_table_local_channel(dvb_mux_t *dm, uint8_t *ptr, int len,
uint16_t tsid, uint16_t onid)
{
uint16_t sid, chan;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
dvb_network_t *dn = dm->dm_dn;
service_t *t;
LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
tdmi->tdmi_mux->dm_network_id == onid)
LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
if(dm->dm_transport_stream_id == tsid && dm->dm_network_id == onid)
break;
if(tdmi == NULL)
if(dm == NULL)
return;
while(len >= 4) {
@ -764,7 +764,7 @@ dvb_table_local_channel(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
chan = ((ptr[2] & 3) << 8) | ptr[3];
if(chan != 0) {
t = dvb_service_find(tdmi, sid, 0, NULL);
t = dvb_service_find(dm->dm_tdmi, sid, 0, NULL);
if(t != NULL) {
if(t->s_channel_number != chan) {
@ -785,7 +785,7 @@ dvb_table_local_channel(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* NIT - Network Information Table
*/
static int
dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_nit_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
uint8_t tag, tlen;
@ -794,11 +794,11 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint16_t tsid, onid;
uint16_t network_id = (ptr[0] << 8) | ptr[1];
if(tdmi->tdmi_adapter->tda_nitoid) {
if(dm->dm_tdmi->tdmi_adapter->tda_nitoid) {
if(tableid != 0x41)
return -1;
if(network_id != tdmi->tdmi_adapter->tda_nitoid)
if(network_id != dm->dm_tdmi->tdmi_adapter->tda_nitoid)
return -1;
} else {
@ -831,8 +831,8 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
if(dvb_get_string(networkname, sizeof(networkname), ptr, tlen, NULL, NULL))
return -1;
if(strcmp(tdmi->tdmi_mux->dm_network_name ?: "", networkname))
dvb_mux_set_networkname(tdmi, networkname);
if(strcmp(dm->dm_network_name ?: "", networkname))
dvb_mux_set_networkname(dm, networkname);
break;
}
@ -869,15 +869,15 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
switch(tag) {
case DVB_DESC_SAT:
if(tdmi->tdmi_adapter->tda_fe_type == FE_QPSK)
dvb_table_sat_delivery(tdmi, ptr, tlen, tsid, onid);
if(dm->dm_dn->dn_fe_type == FE_QPSK)
dvb_table_sat_delivery(dm, ptr, tlen, tsid, onid);
break;
case DVB_DESC_CABLE:
if(tdmi->tdmi_adapter->tda_fe_type == FE_QAM)
dvb_table_cable_delivery(tdmi, ptr, tlen, tsid, onid);
if(dm->dm_dn->dn_fe_type == FE_QAM)
dvb_table_cable_delivery(dm, ptr, tlen, tsid, onid);
break;
case DVB_DESC_LOCAL_CHAN:
dvb_table_local_channel(tdmi, ptr, tlen, tsid, onid);
dvb_table_local_channel(dm, ptr, tlen, tsid, onid);
break;
}
@ -894,10 +894,10 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* VCT - ATSC Virtual Channel Table
*/
static int
atsc_vct_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
atsc_vct_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
dvb_network_t *dn = dm->dm_dn;
service_t *t;
int numch;
char chname[256];
@ -932,16 +932,15 @@ atsc_vct_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
onid = (ptr[24] << 8) | ptr[25];
/* Search all muxes on adapter */
LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
tdmi->tdmi_mux->dm_network_id == onid);
LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
if(dm->dm_transport_stream_id == tsid && dm->dm_network_id == onid);
break;
if(tdmi == NULL)
if(dm == NULL)
continue;
service_id = (ptr[24] << 8) | ptr[25];
if((t = dvb_service_find(tdmi, service_id, 0, NULL)) == NULL)
if((t = dvb_service_find(dm->dm_tdmi, service_id, 0, NULL)) == NULL)
continue;
atsc_stype = ptr[27] & 0x3f;
@ -979,12 +978,13 @@ atsc_vct_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* PMT - Program Mapping Table
*/
static int
dvb_pmt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
dvb_pmt_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
int active = 0;
service_t *t;
th_dvb_table_t *tdt = opaque;
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
LIST_FOREACH(t, &tdmi->tdmi_mux->dm_services, s_group_link) {
pthread_mutex_lock(&t->s_stream_mutex);
@ -1005,23 +1005,23 @@ dvb_pmt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
* Demux for default DVB tables that we want
*/
static void
dvb_table_add_default_dvb(th_dvb_mux_instance_t *tdmi)
dvb_table_add_default_dvb(dvb_mux_t *dm)
{
/* Network Information Table */
int table;
if(tdmi->tdmi_adapter->tda_nitoid) {
if(dm->dm_tdmi->tdmi_adapter->tda_nitoid) {
table = 0x41;
} else {
table = 0x40;
}
tdt_add(tdmi, table, 0xff, dvb_nit_callback, NULL, "nit",
tdt_add(dm, table, 0xff, dvb_nit_callback, NULL, "nit",
TDT_QUICKREQ | TDT_CRC, 0x10);
/* Service Descriptor Table and Bouqeut Allocation Table */
tdt_add(tdmi, 0, 0, dvb_pidx11_callback, NULL, "pidx11",
tdt_add(dm, 0, 0, dvb_pidx11_callback, NULL, "pidx11",
TDT_QUICKREQ | TDT_CRC, 0x11);
}
@ -1030,17 +1030,17 @@ dvb_table_add_default_dvb(th_dvb_mux_instance_t *tdmi)
* Demux for default ATSC tables that we want
*/
static void
dvb_table_add_default_atsc(th_dvb_mux_instance_t *tdmi)
dvb_table_add_default_atsc(dvb_mux_t *dm)
{
int tableid;
if(tdmi->tdmi_mux->dm_conf.dmc_fe_params.u.vsb.modulation == VSB_8) {
if(dm->dm_conf.dmc_fe_params.u.vsb.modulation == VSB_8) {
tableid = 0xc8; // Terrestrial
} else {
tableid = 0xc9; // Cable
}
tdt_add(tdmi, tableid, 0xff, atsc_vct_callback, NULL, "vct",
tdt_add(dm, tableid, 0xff, atsc_vct_callback, NULL, "vct",
TDT_QUICKREQ | TDT_CRC, 0x1ffb);
}
@ -1051,26 +1051,26 @@ dvb_table_add_default_atsc(th_dvb_mux_instance_t *tdmi)
* Setup FD + demux for default tables that we want
*/
void
dvb_table_add_default(th_dvb_mux_instance_t *tdmi)
dvb_table_add_default(dvb_mux_t *dm)
{
/* Program Allocation Table */
tdt_add(tdmi, 0x00, 0xff, dvb_pat_callback, NULL, "pat",
tdt_add(dm, 0x00, 0xff, dvb_pat_callback, NULL, "pat",
TDT_QUICKREQ | TDT_CRC, 0);
/* Conditional Access Table */
tdt_add(tdmi, 0x1, 0xff, dvb_cat_callback, NULL, "cat",
tdt_add(dm, 0x1, 0xff, dvb_cat_callback, NULL, "cat",
TDT_CRC, 1);
switch(tdmi->tdmi_adapter->tda_fe_type) {
switch(dm->dm_dn->dn_fe_type) {
case FE_QPSK:
case FE_OFDM:
case FE_QAM:
dvb_table_add_default_dvb(tdmi);
dvb_table_add_default_dvb(dm);
break;
case FE_ATSC:
dvb_table_add_default_atsc(tdmi);
dvb_table_add_default_atsc(dm);
break;
}
}
@ -1080,24 +1080,26 @@ dvb_table_add_default(th_dvb_mux_instance_t *tdmi)
* Setup FD + demux for a services PMT
*/
void
dvb_table_add_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid)
dvb_table_add_pmt(dvb_mux_t *dm, int pmt_pid)
{
char pmtname[100];
snprintf(pmtname, sizeof(pmtname), "PMT(%d)", pmt_pid);
tdt_add(tdmi, 0x2, 0xff, dvb_pmt_callback, NULL, pmtname,
tdt_add(dm, 0x2, 0xff, dvb_pmt_callback, NULL, pmtname,
TDT_CRC | TDT_QUICKREQ | TDT_TDT, pmt_pid);
}
void
dvb_table_rem_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid)
dvb_table_rem_pmt(dvb_mux_t *dm, int pmt_pid)
{
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
th_dvb_table_t *tdt = NULL;
LIST_FOREACH(tdt, &tdmi->tdmi_tables, tdt_link)
if (tdt->tdt_pid == pmt_pid && tdt->tdt_callback == dvb_pmt_callback)
break;
if (tdt) dvb_tdt_destroy(tda, tdmi, tdt);
if (tdt)
dvb_tdt_destroy(tda, tdmi, tdt);
}

20
src/epggrab.h
View file

@ -169,10 +169,10 @@ struct epggrab_module_ext
*/
struct epggrab_ota_mux
{
TAILQ_ENTRY(epggrab_ota_mux) glob_link; ///< Grabber link
TAILQ_ENTRY(epggrab_ota_mux) tdmi_link; ///< Link to mux
TAILQ_ENTRY(epggrab_ota_mux) grab_link; ///< Link to grabber
struct th_dvb_mux_instance *tdmi; ///< Mux instance
TAILQ_ENTRY(epggrab_ota_mux) glob_link;///< Grabber link
TAILQ_ENTRY(epggrab_ota_mux) dm_link; ///< Link to dvb mux
TAILQ_ENTRY(epggrab_ota_mux) grab_link;///< Link to grabber
struct dvb_mux *dm; ///< Mux instance
epggrab_module_ota_t *grab; ///< Grab instance
int timeout; ///< Time out if this long
@ -203,7 +203,7 @@ struct epggrab_module_ota
TAILQ_HEAD(, epggrab_ota_mux) muxes; ///< List of related muxes
/* Transponder tuning */
void (*start) ( epggrab_module_ota_t *m, struct th_dvb_mux_instance *tdmi );
void (*start) ( epggrab_module_ota_t *m, struct dvb_mux *dm );
};
/*
@ -259,11 +259,11 @@ void epggrab_channel_mod ( struct channel *ch );
/*
* Transport handling
*/
void epggrab_mux_start ( struct th_dvb_mux_instance *tdmi );
void epggrab_mux_stop ( struct th_dvb_mux_instance *tdmi, int timeout );
void epggrab_mux_delete ( struct th_dvb_mux_instance *tdmi );
int epggrab_mux_period ( struct th_dvb_mux_instance *tdmi );
struct th_dvb_mux_instance *epggrab_mux_next ( struct th_dvb_adapter *tda );
void epggrab_mux_start ( struct dvb_mux *tdmi );
void epggrab_mux_stop ( struct dvb_mux *tdmi, int timeout );
void epggrab_mux_delete ( struct dvb_mux *tdmi );
int epggrab_mux_period ( struct dvb_mux *tdmi );
struct dvb_mux *epggrab_mux_next ( struct th_dvb_adapter *tda );
/*
* Re-schedule

2
src/epggrab/module.c
View file

@ -457,7 +457,7 @@ epggrab_module_ota_t *epggrab_module_ota_create
( epggrab_module_ota_t *skel,
const char *id, const char *name, int priority,
void (*start) (epggrab_module_ota_t*m,
struct th_dvb_mux_instance *tdmi),
struct dvb_mux *dm),
int (*enable) (void *m, uint8_t e ),
epggrab_channel_tree_t *channels )
{

37
src/epggrab/module/eit.c
View file

@ -654,9 +654,9 @@ static int _eit_process_event
return ret;
}
static int _eit_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t tableid, void *opaque )
static int
_eit_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
epggrab_module_t *mod = opaque;
epggrab_ota_mux_t *ota;
@ -672,7 +672,7 @@ static int _eit_callback
if(tableid < 0x4e || tableid > 0x6f || len < 11) return -1;
/* Get OTA */
ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi);
ota = epggrab_ota_find((epggrab_module_ota_t*)mod, dm);
if (!ota || !ota->status) return -1;
sta = ota->status;
@ -713,24 +713,26 @@ static int _eit_callback
// Note: tableid=0x4f,0x60-0x6f is other TS
// so must find the tdmi
if(tableid == 0x4f || tableid >= 0x60) {
tda = tdmi->tdmi_adapter;
tdmi = dvb_mux_find(tda, NULL, onid, tsid, 1);
tda = dm->dm_tdmi->tdmi_adapter;
th_dvb_mux_instance_t *tdmi = dvb_mux_find(tda, NULL, onid, tsid, 1);
dm = tdmi->tdmi_mux;
} else {
if (tdmi->tdmi_mux->dm_transport_stream_id != tsid ||
tdmi->tdmi_mux->dm_network_id != onid) {
if (dm->dm_transport_stream_id != tsid ||
dm->dm_network_id != onid) {
#ifdef EPG_EIT_TRACE
tvhlog(LOG_DEBUG, mod->id,
"invalid transport id found tid 0x%02X, onid:tsid %d:%d != %d:%d",
tableid, tdmi->tdmi_network_id, tdmi->tdmi_transport_stream_id,
onid, tsid);
#endif
tdmi = NULL;
dm = NULL;
}
}
if(!tdmi) goto done;
if(!dm) goto done;
/* Get service */
svc = dvb_service_find3(NULL, tdmi, NULL, 0, 0, sid, 1, 1);
svc = dvb_service_find3(NULL, dm->dm_tdmi, NULL, 0, 0, sid, 1, 1);
if (!svc || !svc->s_ch) goto done;
/* Register as interesting */
@ -815,10 +817,9 @@ static void _eit_ota_destroy ( epggrab_ota_mux_t *ota )
}
static void _eit_start
( epggrab_module_ota_t *m, th_dvb_mux_instance_t *tdmi )
( epggrab_module_ota_t *m, dvb_mux_t *dm )
{
epggrab_ota_mux_t *ota;
/* Disabled */
if (!m->enabled) return;
@ -830,7 +831,7 @@ static void _eit_start
}
/* Register */
if (!(ota = epggrab_ota_create(m, tdmi))) return;
if (!(ota = epggrab_ota_create(m, dm))) return;
if (!ota->status) {
ota->status = calloc(1, sizeof(eit_status_t));
ota->destroy = _eit_ota_destroy;
@ -842,16 +843,16 @@ static void _eit_start
tdt_add(tdmi, 0, 0, dvb_pidx11_callback, m, m->id, TDT_CRC, 3840, NULL);
tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 3841, NULL);
#endif
tdt_add(tdmi, 0, 0, dvb_pidx11_callback, m, m->id, TDT_CRC, 3002);
tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 3003);
tdt_add(dm, 0, 0, dvb_pidx11_callback, m, m->id, TDT_CRC, 3002);
tdt_add(dm, 0, 0, _eit_callback, m, m->id, TDT_CRC, 3003);
/* Viasat Baltic (0x39) */
} else if (!strcmp("viasat_baltic", m->id)) {
tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x39);
tdt_add(dm, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x39);
/* Standard (0x12) */
} else {
tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x12);
tdt_add(dm, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x12);
}
tvhlog(LOG_DEBUG, m->id, "install table handlers");
}

28
src/epggrab/module/opentv.c
View file

@ -519,11 +519,11 @@ static int _opentv_bat_section
* ***********************************************************************/
static epggrab_ota_mux_t *_opentv_event_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
{
th_dvb_table_t *tdt = p;
opentv_module_t *mod = tdt->tdt_opaque;
epggrab_ota_mux_t *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi);
epggrab_ota_mux_t *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, dm);
opentv_status_t *sta;
opentv_pid_t *pid;
@ -584,9 +584,9 @@ static epggrab_ota_mux_t *_opentv_event_callback
}
static int _opentv_title_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
{
epggrab_ota_mux_t *ota = _opentv_event_callback(tdmi, buf, len, tid, p);
epggrab_ota_mux_t *ota = _opentv_event_callback(dm, buf, len, tid, p);
if (ota)
return _opentv_parse_event_section((opentv_module_t*)ota->grab,
(opentv_status_t*)ota->status,
@ -595,9 +595,9 @@ static int _opentv_title_callback
}
static int _opentv_summary_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
{
epggrab_ota_mux_t *ota = _opentv_event_callback(tdmi, buf, len, tid, p);
epggrab_ota_mux_t *ota = _opentv_event_callback(dm, buf, len, tid, p);
if (ota)
return _opentv_parse_event_section((opentv_module_t*)ota->grab,
(opentv_status_t*)ota->status,
@ -606,10 +606,10 @@ static int _opentv_summary_callback
}
static int _opentv_channel_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
{
opentv_module_t *mod = p;
epggrab_ota_mux_t *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi);
epggrab_ota_mux_t *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, dm);
opentv_status_t *sta;
if (!ota || !ota->status) return 0;
sta = ota->status;
@ -642,7 +642,7 @@ static void _opentv_ota_destroy ( epggrab_ota_mux_t *ota )
}
static void _opentv_start
( epggrab_module_ota_t *m, th_dvb_mux_instance_t *tdmi )
( epggrab_module_ota_t *m, dvb_mux_t *dm )
{
int *t;
epggrab_ota_mux_t *ota;
@ -651,10 +651,10 @@ static void _opentv_start
/* Ignore */
if (!m->enabled) return;
if (mod->tsid != tdmi->tdmi_mux->dm_transport_stream_id) return;
if (mod->tsid != dm->dm_transport_stream_id) return;
/* Create link */
if (!(ota = epggrab_ota_create(m, tdmi))) return;
if (!(ota = epggrab_ota_create(m, dm))) return;
if (!ota->status) {
ota->status = calloc(1, sizeof(opentv_status_t));
ota->destroy = _opentv_ota_destroy;
@ -672,7 +672,7 @@ static void _opentv_start
t = mod->channel;
while (*t) {
// TODO: what about 0x46 (service description)
tdt_add(tdmi, 0x4a, 0xff, _opentv_channel_callback, m,
tdt_add(dm, 0x4a, 0xff, _opentv_channel_callback, m,
m->id, TDT_CRC, *t++);
}
@ -680,7 +680,7 @@ static void _opentv_start
t = mod->title;
while (*t) {
_opentv_status_get_pid(sta, *t);
tdt_add(tdmi, 0xa0, 0xfc, _opentv_title_callback, m,
tdt_add(dm, 0xa0, 0xfc, _opentv_title_callback, m,
m->id, TDT_CRC | TDT_TDT, *t++);
}
@ -688,7 +688,7 @@ static void _opentv_start
t = mod->summary;
while (*t) {
_opentv_status_get_pid(sta, *t);
tdt_add(tdmi, 0xa8, 0xfc, _opentv_summary_callback, m,
tdt_add(dm, 0xa8, 0xfc, _opentv_summary_callback, m,
m->id, TDT_CRC | TDT_TDT, *t++);
}
}

55
src/epggrab/otamux.c
View file

@ -36,27 +36,27 @@ TAILQ_HEAD(, epggrab_ota_mux) ota_mux_all;
* Global functions (called from DVB code)
* *************************************************************************/
void epggrab_mux_start ( th_dvb_mux_instance_t *tdmi )
void epggrab_mux_start ( dvb_mux_t *dm )
{
epggrab_module_t *m;
epggrab_module_ota_t *om;
LIST_FOREACH(m, &epggrab_modules, link) {
if (m->type == EPGGRAB_OTA) {
om = (epggrab_module_ota_t*)m;
if (om->start) om->start(om, tdmi);
if (om->start) om->start(om, dm);
}
}
}
void epggrab_mux_stop ( th_dvb_mux_instance_t *tdmi, int timeout )
void epggrab_mux_stop ( dvb_mux_t *dm, int timeout )
{
// Note: the slightly akward list iteration here is because
// _ota_cancel/delete can remove the object and free() it
epggrab_ota_mux_t *a, *b;
a = TAILQ_FIRST(&tdmi->tdmi_epg_grab);
a = TAILQ_FIRST(&dm->dm_epg_grab);
while (a) {
b = TAILQ_NEXT(a, tdmi_link);
if (a->tdmi == tdmi) {
b = TAILQ_NEXT(a, dm_link);
if (a->dm == dm) {
if (timeout)
epggrab_ota_timeout(a);
else
@ -66,16 +66,16 @@ void epggrab_mux_stop ( th_dvb_mux_instance_t *tdmi, int timeout )
}
}
void epggrab_mux_delete ( th_dvb_mux_instance_t *tdmi )
void epggrab_mux_delete ( dvb_mux_t *dm )
{
epggrab_ota_destroy_by_tdmi(tdmi);
epggrab_ota_destroy_by_dm(dm);
}
int epggrab_mux_period ( th_dvb_mux_instance_t *tdmi )
int epggrab_mux_period ( dvb_mux_t *dm )
{
int period = 0;
epggrab_ota_mux_t *ota;
TAILQ_FOREACH(ota, &tdmi->tdmi_epg_grab, tdmi_link) {
TAILQ_FOREACH(ota, &dm->dm_epg_grab, dm_link) {
if (!ota->is_reg) continue;
if (ota->timeout > period)
period = ota->timeout;
@ -83,7 +83,7 @@ int epggrab_mux_period ( th_dvb_mux_instance_t *tdmi )
return period;
}
th_dvb_mux_instance_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
dvb_mux_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
{
time_t now;
epggrab_ota_mux_t *ota;
@ -91,9 +91,9 @@ th_dvb_mux_instance_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
TAILQ_FOREACH(ota, &ota_mux_all, glob_link) {
if (ota->interval + ota->completed > now) return NULL;
if (!ota->is_reg) return NULL;
if (ota->tdmi->tdmi_adapter == tda) break;
if (ota->dm->dm_tdmi->tdmi_adapter == tda) break;
}
return ota ? ota->tdmi : NULL;
return ota ? ota->dm : NULL;
}
/* **************************************************************************
@ -148,7 +148,7 @@ static void _epggrab_ota_save_one ( htsmsg_t *m, epggrab_module_ota_t *mod )
if (!l) l = htsmsg_create_list();
e = htsmsg_create_map();
const dvb_mux_t *dm = ota->tdmi->tdmi_mux;
const dvb_mux_t *dm = ota->dm;
htsmsg_add_u32(e, "onid", dm->dm_network_id);
htsmsg_add_u32(e, "tsid", dm->dm_transport_stream_id);
@ -212,11 +212,11 @@ static int _ota_time_cmp ( void *_a, void *_b )
* Find existing link
*/
epggrab_ota_mux_t *epggrab_ota_find
( epggrab_module_ota_t *mod, th_dvb_mux_instance_t *tdmi )
( epggrab_module_ota_t *mod, dvb_mux_t *dm )
{
epggrab_ota_mux_t *ota;
TAILQ_FOREACH(ota, &mod->muxes, grab_link) {
if (ota->tdmi == tdmi) break;
if (ota->dm == dm) break;
}
return ota;
}
@ -225,18 +225,18 @@ epggrab_ota_mux_t *epggrab_ota_find
* Create (temporary) or Find (existing) link
*/
epggrab_ota_mux_t *epggrab_ota_create
( epggrab_module_ota_t *mod, th_dvb_mux_instance_t *tdmi )
( epggrab_module_ota_t *mod, dvb_mux_t *dm)
{
/* Search for existing */
epggrab_ota_mux_t *ota = epggrab_ota_find(mod, tdmi);
epggrab_ota_mux_t *ota = epggrab_ota_find(mod, dm);
/* Create new */
if (!ota) {
ota = calloc(1, sizeof(epggrab_ota_mux_t));
ota->grab = mod;
ota->tdmi = tdmi;
ota->dm = dm;
TAILQ_INSERT_TAIL(&ota_mux_all, ota, glob_link);
TAILQ_INSERT_TAIL(&tdmi->tdmi_epg_grab, ota, tdmi_link);
TAILQ_INSERT_TAIL(&dm->dm_epg_grab, ota, dm_link);
TAILQ_INSERT_TAIL(&mod->muxes, ota, grab_link);
} else {
@ -259,12 +259,12 @@ void epggrab_ota_create_and_register_by_id
epggrab_ota_mux_t *ota;
TAILQ_FOREACH(tda, &dvb_adapters, tda_global_link) {
LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link) {
const dvb_mux_t *dm = tdmi->tdmi_mux;
dvb_mux_t *dm = tdmi->tdmi_mux;
if (dm->dm_transport_stream_id != tsid) continue;
if (onid && dm->dm_network_id != onid) continue;
if (networkname && (!dm->dm_network_name ||
strcmp(networkname, dm->dm_network_name))) continue;
ota = epggrab_ota_create(mod, tdmi);
ota = epggrab_ota_create(mod, dm);
epggrab_ota_register(ota, period, interval);
}
}
@ -276,7 +276,7 @@ void epggrab_ota_create_and_register_by_id
void epggrab_ota_destroy ( epggrab_ota_mux_t *ota )
{
TAILQ_REMOVE(&ota_mux_all, ota, glob_link);
TAILQ_REMOVE(&ota->tdmi->tdmi_epg_grab, ota, tdmi_link);
TAILQ_REMOVE(&ota->dm->dm_epg_grab, ota, dm_link);
TAILQ_REMOVE(&ota->grab->muxes, ota, grab_link);
if (ota->destroy) ota->destroy(ota);
else {
@ -288,10 +288,10 @@ void epggrab_ota_destroy ( epggrab_ota_mux_t *ota )
/*
* Destroy by tdmi
*/
void epggrab_ota_destroy_by_tdmi ( th_dvb_mux_instance_t *tdmi )
void epggrab_ota_destroy_by_dm ( dvb_mux_t *dm )
{
epggrab_ota_mux_t *ota;
while ((ota = TAILQ_FIRST(&tdmi->tdmi_epg_grab)))
while ((ota = TAILQ_FIRST(&dm->dm_epg_grab)))
epggrab_ota_destroy(ota);
}
@ -359,7 +359,7 @@ int epggrab_ota_begin ( epggrab_ota_mux_t *ota )
void epggrab_ota_complete ( epggrab_ota_mux_t *ota )
{
th_dvb_mux_instance_t *tdmi = ota->tdmi;
dvb_mux_t *dm = ota->dm;
if (ota->state != EPGGRAB_OTA_MUX_COMPLETE) {
tvhlog(LOG_DEBUG, ota->grab->id, "processing complete");
@ -367,12 +367,13 @@ void epggrab_ota_complete ( epggrab_ota_mux_t *ota )
time(&ota->completed);
/* Check others */
TAILQ_FOREACH(ota, &tdmi->tdmi_epg_grab, tdmi_link) {
TAILQ_FOREACH(ota, &dm->dm_epg_grab, dm_link) {
if (ota->is_reg && ota->state == EPGGRAB_OTA_MUX_RUNNING) break;
}
/* All complete (bring timer forward) */
if (!ota) {
th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
gtimer_arm(&tdmi->tdmi_adapter->tda_mux_scanner_timer,
dvb_adapter_mux_scanner, tdmi->tdmi_adapter, 20);
}

8
src/epggrab/private.h
View file

@ -88,7 +88,7 @@ epggrab_module_ota_t *epggrab_module_ota_create
( epggrab_module_ota_t *skel,
const char *id, const char *name, int priority,
void (*start) (epggrab_module_ota_t*m,
struct th_dvb_mux_instance *tdmi),
struct dvb_mux *dm),
int (*enable) (void *m, uint8_t e ),
epggrab_channel_tree_t *channels );
@ -109,9 +109,9 @@ void epggrab_ota_save ( void );
* blocked (i.e. has completed within interval period)
*/
epggrab_ota_mux_t *epggrab_ota_find
( epggrab_module_ota_t *mod, struct th_dvb_mux_instance *tdmi );
( epggrab_module_ota_t *mod, struct dvb_mux *dm );
epggrab_ota_mux_t *epggrab_ota_create
( epggrab_module_ota_t *mod, struct th_dvb_mux_instance *tdmi );
( epggrab_module_ota_t *mod, struct dvb_mux *dm );
void epggrab_ota_create_and_register_by_id
( epggrab_module_ota_t *mod, int nid, int tsid,
int period, int interval, const char *name );
@ -121,7 +121,7 @@ void epggrab_ota_create_and_register_by_id
*/
void epggrab_ota_destroy ( epggrab_ota_mux_t *ota );
void epggrab_ota_destroy_by_module ( epggrab_module_ota_t *mod );
void epggrab_ota_destroy_by_tdmi ( struct th_dvb_mux_instance *tdmi );
void epggrab_ota_destroy_by_dm ( struct dvb_mux *dm );
/*
* Register interest