diff --git a/Makefile b/Makefile
index 2c8178e9..ec07efd0 100644
--- a/Makefile
+++ b/Makefile
@@ -74,11 +74,13 @@ SRCS = src/main.c \
src/avc.c \
src/huffman.c \
-SRCS += src/epggrab/pyepg.c\
- src/epggrab/xmltv.c\
- src/epggrab/ota.c \
- src/epggrab/eit.c \
- src/epggrab/opentv.c \
+SRCS += src/epggrab/module.c\
+ src/epggrab/channel.c\
+ src/epggrab/otamux.c\
+ src/epggrab/module/pyepg.c\
+ src/epggrab/module/xmltv.c\
+ src/epggrab/module/eit.c \
+ src/epggrab/module/opentv.c \
SRCS += src/plumbing/tsfix.c \
src/plumbing/globalheaders.c \
diff --git a/src/dvb/dvb_adapter.c b/src/dvb/dvb_adapter.c
index 39c690c8..77427bbc 100644
--- a/src/dvb/dvb_adapter.c
+++ b/src/dvb/dvb_adapter.c
@@ -444,10 +444,12 @@ dvb_adapter_mux_scanner(void *aux)
}
/* Check EPG */
- if (tda->tda_mux_epg)
+ if (tda->tda_mux_epg) {
+ epggrab_mux_stop(tda->tda_mux_epg, 1); // timeout anything not complete
tda->tda_mux_epg = NULL; // skip this time
- else
+ } else {
tda->tda_mux_epg = epggrab_mux_next(tda);
+ }
/* Idle or EPG scan enabled */
idle_epg = tda->tda_idlescan || tda->tda_mux_epg;
diff --git a/src/dvb/dvb_fe.c b/src/dvb/dvb_fe.c
index aedab5a0..388fe5ef 100644
--- a/src/dvb/dvb_fe.c
+++ b/src/dvb/dvb_fe.c
@@ -231,7 +231,7 @@ dvb_fe_stop(th_dvb_mux_instance_t *tdmi)
dvb_mux_add_to_scan_queue(tdmi);
}
- epggrab_mux_stop(tdmi);
+ epggrab_mux_stop(tdmi, 0);
time(&tdmi->tdmi_lost_adapter);
}
diff --git a/src/epggrab.c b/src/epggrab.c
index fb8816e0..213b3af6 100644
--- a/src/epggrab.c
+++ b/src/epggrab.c
@@ -13,10 +13,7 @@
#include "queue.h"
#include "epg.h"
#include "epggrab.h"
-#include "epggrab/eit.h"
-#include "epggrab/xmltv.h"
-#include "epggrab/pyepg.h"
-#include "epggrab/opentv.h"
+#include "epggrab/private.h"
#include "channels.h"
#include "spawn.h"
#include "htsmsg_xml.h"
@@ -30,7 +27,7 @@ pthread_cond_t epggrab_cond;
/* Config */
uint32_t epggrab_interval;
-epggrab_module_t* epggrab_module;
+epggrab_module_int_t* epggrab_module;
epggrab_module_list_t epggrab_modules;
uint32_t epggrab_channel_rename;
uint32_t epggrab_channel_renumber;
@@ -40,15 +37,20 @@ uint32_t epggrab_channel_reicon;
* Helpers
* *************************************************************************/
+void epggrab_resched ( void )
+{
+}
+
/*
* Run the parse
*/
-static void _epggrab_module_parse
- ( epggrab_module_t *mod, htsmsg_t *data )
+void epggrab_module_parse
+ ( void *m, htsmsg_t *data )
{
time_t tm1, tm2;
int save = 0;
epggrab_stats_t stats;
+ epggrab_module_int_t *mod = m;
/* Parse */
memset(&stats, 0, sizeof(stats));
@@ -82,7 +84,7 @@ static void _epggrab_module_parse
/*
* Grab from module
*/
-static void _epggrab_module_grab ( epggrab_module_t *mod )
+static void _epggrab_module_grab ( epggrab_module_int_t *mod )
{
time_t tm1, tm2;
htsmsg_t *data;
@@ -95,41 +97,14 @@ static void _epggrab_module_grab ( epggrab_module_t *mod )
/* Process */
if ( data ) {
tvhlog(LOG_INFO, mod->id, "grab took %d seconds", tm2 - tm1);
- _epggrab_module_parse(mod, data);
+ epggrab_module_parse(mod, data);
} else {
tvhlog(LOG_WARNING, mod->id, "grab returned no data");
}
}
-/*
- * Socket handler
- */
-static void _epggrab_socket_handler ( epggrab_module_t *mod, int s )
-{
- size_t outlen;
- char *outbuf;
- time_t tm1, tm2;
- htsmsg_t *data = NULL;
-
- /* Grab/Translate */
- time(&tm1);
- outlen = file_readall(s, &outbuf);
- if (outlen) data = mod->trans(mod, outbuf);
- time(&tm2);
-
- /* Process */
- if ( data ) {
- tvhlog(LOG_INFO, mod->id, "grab took %d seconds", tm2 - tm1);
- _epggrab_module_parse(mod, data);
-
- /* Failed */
- } else {
- tvhlog(LOG_ERR, mod->id, "failed to read data");
- }
-}
-
/* **************************************************************************
- * Threads
+ * Internal Grab Thread
* *************************************************************************/
/*
@@ -139,7 +114,7 @@ static void* _epggrab_internal_thread ( void* p )
{
int err, confver = -1; // force first run
struct timespec ts;
- epggrab_module_t *mod;
+ epggrab_module_int_t *mod;
/* Setup timeout */
ts.tv_nsec = 0;
@@ -169,473 +144,6 @@ static void* _epggrab_internal_thread ( void* p )
return NULL;
}
-/*
- * External (socket) grab thread
- */
-static void *_epggrab_socket_thread ( void *p )
-{
- int s;
- epggrab_module_t *mod = (epggrab_module_t*)p;
- tvhlog(LOG_INFO, mod->id, "external socket enabled");
-
- while ( mod->enabled && mod->sock ) {
- tvhlog(LOG_DEBUG, mod->id, "waiting for connection");
- s = accept(mod->sock, NULL, NULL);
- if (s <= 0) continue;
- tvhlog(LOG_DEBUG, mod->id, "got connection %d", s);
- _epggrab_socket_handler(mod, s);
- }
- tvhlog(LOG_DEBUG, mod->id, "terminated");
- return NULL;
-}
-
-/* **************************************************************************
- * Base Module functions
- * *************************************************************************/
-
-static int _ch_id_cmp ( void *a, void *b )
-{
- return strcmp(((epggrab_channel_t*)a)->id,
- ((epggrab_channel_t*)b)->id);
-}
-
-static int _ch_link ( epggrab_channel_t *ec, channel_t *ch )
-{
- service_t *sv;
- int match = 0, i;
-
- if (!ec || !ch) return 0;
- if (ec->channel) return 0;
-
- if (ec->name && !strcmp(ec->name, ch->ch_name))
- match = 1;
- else {
- LIST_FOREACH(sv, &ch->ch_services, s_ch_link) {
- if (ec->sid) {
- for (i = 0; i < ec->sid_cnt; i++ ) {
- if (sv->s_dvb_service_id == ec->sid[i]) {
- match = 1;
- break;
- }
- }
- }
- if (!match && ec->sname) {
- i = 0;
- while (ec->sname[i]) {
- if (!strcmp(ec->sname[i], sv->s_svcname)) {
- match = 1;
- break;
- }
- i++;
- }
- }
- if (match) break;
- }
- }
-
- if (match) {
- tvhlog(LOG_INFO, ec->mod->id, "linking %s to %s",
- ec->id, ch->ch_name);
- ec->channel = ch;
- if (ec->name && epggrab_channel_rename)
- channel_rename(ch, ec->name);
- if (ec->icon && epggrab_channel_reicon)
- channel_set_icon(ch, ec->icon);
- if (ec->number>0 && epggrab_channel_renumber)
- channel_set_number(ch, ec->number);
- }
-
- return match;
-}
-
-int epggrab_module_enable_socket ( epggrab_module_t *mod, uint8_t e )
-{
- pthread_t tid;
- pthread_attr_t tattr;
- struct sockaddr_un addr;
- assert(mod->path);
- assert(mod->flags & EPGGRAB_MODULE_EXTERNAL);
-
- /* Ignore */
- if ( mod->enabled == e ) return 0;
-
- /* Disable */
- if (!e) {
- shutdown(mod->sock, SHUT_RDWR);
- close(mod->sock);
- unlink(mod->path);
- mod->sock = 0;
-
- /* Enable */
- } else {
- unlink(mod->path); // just in case!
-
- mod->sock = socket(AF_UNIX, SOCK_STREAM, 0);
- assert(mod->sock);
-
- memset(&addr, 0, sizeof(struct sockaddr_un));
- addr.sun_family = AF_UNIX;
- strncpy(addr.sun_path, mod->path, 100);
- if ( bind(mod->sock, (struct sockaddr*)&addr,
- sizeof(struct sockaddr_un)) != 0 ) {
- tvhlog(LOG_ERR, mod->id, "failed to bind socket");
- close(mod->sock);
- mod->sock = 0;
- return 0;
- }
-
- if ( listen(mod->sock, 5) != 0 ) {
- tvhlog(LOG_ERR, mod->id, "failed to listen on socket");
- close(mod->sock);
- mod->sock = 0;
- return 0;
- }
-
- tvhlog(LOG_DEBUG, mod->id, "starting socket thread");
- pthread_attr_init(&tattr);
- pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
- pthread_create(&tid, &tattr, _epggrab_socket_thread, mod);
- }
- mod->enabled = e;
- return 1;
-}
-
-const char *epggrab_module_socket_path ( const char *id )
-{
- char *ret = malloc(100);
- snprintf(ret, 100, "%s/epggrab/%s.sock",
- hts_settings_get_root(), id);
- return ret;
-}
-
-char *epggrab_module_grab ( epggrab_module_t *mod )
-{
- int outlen;
- char *outbuf;
-
- /* Debug */
- tvhlog(LOG_INFO, mod->id, "grab %s", mod->path);
-
- /* Grab */
- outlen = spawn_and_store_stdout(mod->path, NULL, &outbuf);
- if ( outlen < 1 ) {
- tvhlog(LOG_ERR, "pyepg", "no output detected");
- return NULL;
- }
-
- return outbuf;
-}
-
-htsmsg_t *epggrab_module_trans_xml
- ( epggrab_module_t *mod, char *c )
-{
- htsmsg_t *ret;
- char errbuf[100];
-
- if (!c) return NULL;
-
- /* Extract */
- ret = htsmsg_xml_deserialize(c, errbuf, sizeof(errbuf));
- if (!ret)
- tvhlog(LOG_ERR, "pyepg", "htsmsg_xml_deserialize error %s", errbuf);
- return ret;
-}
-
-void epggrab_module_channel_save
- ( epggrab_module_t *mod, epggrab_channel_t *ch )
-{
- int i;
- htsmsg_t *m = htsmsg_create_map();
- htsmsg_t *a;
-
- if (ch->name)
- htsmsg_add_str(m, "name", ch->name);
- if (ch->icon)
- htsmsg_add_str(m, "icon", ch->icon);
- if (ch->channel)
- htsmsg_add_u32(m, "channel", ch->channel->ch_id);
- if (ch->sid) {
- a = htsmsg_create_list();
- for (i = 0; i < ch->sid_cnt; i++ ) {
- htsmsg_add_u32(a, NULL, ch->sid[i]);
- }
- htsmsg_add_msg(m, "sid", a);
- }
- if (ch->sname) {
- a = htsmsg_create_list();
- i = 0;
- while (ch->sname[i]) {
- htsmsg_add_str(a, NULL, ch->sname[i]);
- i++;
- }
- htsmsg_add_msg(m, "sname", a);
- }
- if (ch->number)
- htsmsg_add_u32(m, "number", ch->number);
-
- hts_settings_save(m, "epggrab/%s/channels/%s", mod->id, ch->id);
-}
-
-static void epggrab_module_channel_load
- ( epggrab_module_t *mod, htsmsg_t *m, const char *id )
-{
- int save = 0, i;
- const char *str;
- uint32_t u32;
- htsmsg_t *a;
- htsmsg_field_t *f;
-
- epggrab_channel_t *ch = epggrab_module_channel_find(mod, id, 1, &save);
-
- if ((str = htsmsg_get_str(m, "name")))
- ch->name = strdup(str);
- if ((str = htsmsg_get_str(m, "icon")))
- ch->icon = strdup(str);
- if ((a = htsmsg_get_list(m, "sid"))) {
- i = 0;
- HTSMSG_FOREACH(f, a) i++;
- ch->sid_cnt = i;
- ch->sid = calloc(i, sizeof(uint16_t));
- i = 0;
- HTSMSG_FOREACH(f, a) {
- ch->sid[i] = (uint16_t)f->hmf_s64;
- i++;
- }
- }
- if ((a = htsmsg_get_list(m, "sname"))) {
- i = 0;
- HTSMSG_FOREACH(f, a) i++;
- ch->sname = calloc(i+1, sizeof(char*));
- i = 0;
- HTSMSG_FOREACH(f, a) {
- ch->sname[i] = strdup(f->hmf_str);
- i++;
- }
- }
- if(!htsmsg_get_u32(m, "number", &u32))
- ch->number = u32;
-
- if (!htsmsg_get_u32(m, "channel", &u32))
- ch->channel = channel_find_by_identifier(u32);
-}
-
-void epggrab_module_channels_load ( epggrab_module_t *mod )
-{
- htsmsg_t *m, *e;
- htsmsg_field_t *f;
-
- if ((m = hts_settings_load("epggrab/%s/channels", mod->id))) {
- HTSMSG_FOREACH(f, m) {
- if ((e = htsmsg_get_map_by_field(f)))
- epggrab_module_channel_load(mod, e, f->hmf_name);
- }
- htsmsg_destroy(m);
- }
-}
-
-void epggrab_module_channel_add ( epggrab_module_t *mod, channel_t *ch )
-{
- epggrab_channel_t *egc;
- RB_FOREACH(egc, mod->channels, link) {
- if (_ch_link(egc, ch) ) {
- epggrab_module_channel_save(mod, egc);
- break;
- }
- }
-}
-
-void epggrab_module_channel_rem ( epggrab_module_t *mod, channel_t *ch )
-{
- epggrab_channel_t *egc;
- RB_FOREACH(egc, mod->channels, link) {
- if (egc->channel == ch) {
- egc->channel = NULL;
- epggrab_module_channel_save(mod, egc);
- break;
- }
- }
-}
-
-void epggrab_module_channel_mod ( epggrab_module_t *mod, channel_t *ch )
-{
- return epggrab_module_channel_add(mod, ch);
-}
-
-
-epggrab_channel_t *epggrab_module_channel_find
- ( epggrab_module_t *mod, const char *id, int create, int *save )
-{
- epggrab_channel_t *ec;
- static epggrab_channel_t *skel = NULL;
-
- if (!mod || !mod->channels ) return NULL;
-
- if ( !skel ) skel = calloc(1, sizeof(epggrab_channel_t));
- skel->id = (char*)id;
- skel->mod = mod;
-
- /* Find */
- if (!create) {
- ec = RB_FIND(mod->channels, skel, link, _ch_id_cmp);
-
- /* Create (if required) */
- } else {
- ec = RB_INSERT_SORTED(mod->channels, skel, link, _ch_id_cmp);
- if ( ec == NULL ) {
- skel->id = strdup(skel->id);
- ec = skel;
- skel = NULL;
- *save = 1;
- }
- }
-
- return ec;
-}
-
-/* **************************************************************************
- * Channels
- * *************************************************************************/
-
-int epggrab_channel_set_name ( epggrab_channel_t *ec, const char *name )
-{
- int save = 0;
- if (!ec || !name) return 0;
- if (!ec->name || strcmp(ec->name, name)) {
- if (ec->name) free(ec->name);
- ec->name = strdup(name);
- if (ec->channel) channel_rename(ec->channel, name);
- save = 1;
- }
- return save;
-}
-
-int epggrab_channel_set_sid
- ( epggrab_channel_t *ec, const uint16_t *sid, int num )
-{
- int save = 0, i = 0;
- if ( !ec || !sid ) return 0;
- if (!ec->sid) save = 1;
- else if (ec->sid_cnt != num) save = 1;
- else {
- for (i = 0; i < num; i++ ) {
- if (sid[i] != ec->sid[i]) {
- save = 1;
- break;
- }
- }
- }
- if (save) {
- if (ec->sid) free(ec->sid);
- ec->sid = calloc(num, sizeof(uint16_t));
- for (i = 0; i < num; i++ ) {
- ec->sid[i] = sid[i];
- }
- ec->sid_cnt = num;
- }
- return save;
-}
-
-int epggrab_channel_set_sname ( epggrab_channel_t *ec, const char **sname )
-{
- int save = 0, i = 0;
- if ( !ec || !sname ) return 0;
- if (!ec->sname) save = 1;
- else {
- while ( ec->sname[i] && sname[i] ) {
- if (strcmp(ec->sname[i], sname[i])) {
- save = 1;
- break;
- }
- i++;
- }
- if (!save && (ec->sname[i] || sname[i])) save = 1;
- }
- if (save) {
- if (ec->sname) {
- i = 0;
- while (ec->sname[i])
- free(ec->sname[i++]);
- free(ec->sname);
- }
- i = 0;
- while (sname[i++]);
- ec->sname = calloc(i+1, sizeof(char*));
- i = 0;
- while (sname[i]) {
- ec->sname[i] = strdup(sname[i]);
- i++;
- }
- }
- return save;
-}
-
-int epggrab_channel_set_icon ( epggrab_channel_t *ec, const char *icon )
-{
- int save = 0;
- if (!ec->icon || strcmp(ec->icon, icon) ) {
- if (!ec | !icon) return 0;
- if (ec->icon) free(ec->icon);
- ec->icon = strdup(icon);
- if (ec->channel) channel_set_icon(ec->channel, icon);
- save = 1;
- }
- return save;
-}
-
-int epggrab_channel_set_number ( epggrab_channel_t *ec, int number )
-{
- int save = 0;
- if (!ec || (number <= 0)) return 0;
- if (ec->number != number) {
- ec->number = number;
- if (ec->channel) channel_set_number(ec->channel, number);
- save = 1;
- }
- return save;
-}
-
-void epggrab_channel_link ( epggrab_channel_t *ec )
-{
- channel_t *ch;
-
- if (!ec) return;
-
- /* Link */
- if (!ec->channel) {
- RB_FOREACH(ch, &channel_name_tree, ch_name_link) {
- if (_ch_link(ec, ch)) break;
- }
- }
-}
-
-void epggrab_channel_updated ( epggrab_channel_t *ec )
-{
- epggrab_channel_link(ec);
- epggrab_module_channel_save(ec->mod, ec);
-}
-
-htsmsg_t *epggrab_channel_list ( void )
-{
- char name[100];
- epggrab_module_t *mod;
- epggrab_channel_t *ec;
- htsmsg_t *e, *m;
- m = htsmsg_create_list();
- LIST_FOREACH(mod, &epggrab_modules, link) {
- if (mod->enabled && mod->channels) {
- RB_FOREACH(ec, mod->channels, link) {
- e = htsmsg_create_map();
- htsmsg_add_str(e, "module", mod->id);
- htsmsg_add_str(e, "id", ec->id);
- sprintf(name, "%s: %s", mod->name, ec->name);
- htsmsg_add_str(e, "name", name);
- htsmsg_add_msg(m, NULL, e);
- }
- }
- }
- return m;
-}
-
/* **************************************************************************
* Configuration
* *************************************************************************/
@@ -664,8 +172,12 @@ static void _epggrab_load ( void )
if (old) epggrab_interval *= 3600;
htsmsg_get_u32(m, "grab-enabled", &enabled);
if (enabled) {
- if ( (str = htsmsg_get_str(m, old ? "current-grabber" : "module")) )
- epggrab_module = epggrab_module_find_by_id(str);
+ if ( (str = htsmsg_get_str(m, old ? "current-grabber" : "module")) ) {
+ mod = epggrab_module_find_by_id(str);
+ if (mod && mod->type == EPGGRAB_INT) {
+ epggrab_module = (epggrab_module_int_t*)mod;
+ }
+ }
if ( (a = htsmsg_get_map(m, "mod_enabled")) ) {
LIST_FOREACH(mod, &epggrab_modules, link) {
if (htsmsg_get_u32_or_default(a, mod->id, 0)) {
@@ -709,7 +221,7 @@ static void _epggrab_load ( void )
epggrab_interval = 12 * 3600; // hours
epggrab_module = NULL; // disabled
LIST_FOREACH(m, &epggrab_modules, link) // enable all OTA by default
- if (m->flags & EPGGRAB_MODULE_OTA)
+ if (m->type == EPGGRAB_OTA)
epggrab_enable_module(m, 1);
}
@@ -759,18 +271,18 @@ int epggrab_set_interval ( uint32_t interval )
return save;
}
-int epggrab_set_module ( epggrab_module_t *mod )
+int epggrab_set_module ( epggrab_module_t *m )
{
int save = 0;
+ epggrab_module_int_t *mod;
+ if (m && m->type != EPGGRAB_INT) return 0;
+ mod = (epggrab_module_int_t*)m;
if ( epggrab_module != mod ) {
- if (epggrab_module) epggrab_enable_module(epggrab_module, 0);
- if (mod) {
- assert(mod->grab);
- assert(mod->trans);
- assert(mod->parse);
- }
- epggrab_module = mod;
- if (epggrab_module) epggrab_enable_module(epggrab_module, 1);
+ if (epggrab_module && epggrab_module->enable)
+ epggrab_module->enable(epggrab_module, 0);
+ epggrab_module = (epggrab_module_int_t*)mod;
+ if (epggrab_module && epggrab_module->enable)
+ epggrab_module->enable(epggrab_module, 1);
save = 1;
}
return save;
@@ -829,75 +341,9 @@ int epggrab_enable_module_by_id ( const char *id, uint8_t e )
}
/* **************************************************************************
- * Global Functions
+ * Module Access
* *************************************************************************/
-/*
- * Initialise
- */
-void epggrab_init ( void )
-{
- /* Initialise modules */
- eit_init(&epggrab_modules);
- xmltv_init(&epggrab_modules);
- pyepg_init(&epggrab_modules);
- opentv_init(&epggrab_modules);
-
- /* Load config */
- _epggrab_load();
-
- /* Start internal grab thread */
- pthread_t tid;
- pthread_attr_t tattr;
- pthread_attr_init(&tattr);
- pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
- pthread_create(&tid, &tattr, _epggrab_internal_thread, NULL);
-}
-
-void epggrab_channel_add ( channel_t *ch )
-{
- epggrab_module_t *m;
- LIST_FOREACH(m, &epggrab_modules, link) {
- if (m->ch_add) m->ch_add(m, ch);
- }
-}
-
-void epggrab_channel_rem ( channel_t *ch )
-{
- epggrab_module_t *m;
- LIST_FOREACH(m, &epggrab_modules, link) {
- if (m->ch_rem) m->ch_rem(m, ch);
- }
-}
-
-void epggrab_channel_mod ( channel_t *ch )
-{
- epggrab_module_t *m;
- LIST_FOREACH(m, &epggrab_modules, link) {
- if (m->ch_mod) m->ch_mod(m, ch);
- }
-}
-
-void epggrab_tune ( th_dvb_mux_instance_t *tdmi )
-{
- epggrab_module_t *m;
- epggrab_ota_mux_t *o;
- th_dvb_mux_instance_t *t;
-
- /* Cancel all currently active ota grabs */
- LIST_FOREACH(t, &tdmi->tdmi_adapter->tda_muxes, tdmi_adapter_link) {
- if (t == tdmi) continue;
- LIST_FOREACH(o, &t->tdmi_epg_grabbers, tdmi_link) {
- epggrab_ota_cancel(o);
- }
- }
-
- /* Inform all modules */
- LIST_FOREACH(m, &epggrab_modules, link) {
- if (m->tune) m->tune(m, tdmi);
- }
-}
-
epggrab_module_t* epggrab_module_find_by_id ( const char *id )
{
epggrab_module_t *m;
@@ -914,11 +360,42 @@ htsmsg_t *epggrab_module_list ( void )
LIST_FOREACH(m, &epggrab_modules, link) {
e = htsmsg_create_map();
htsmsg_add_str(e, "id", m->id);
- if(m->name) htsmsg_add_str(e, "name", m->name);
- if(m->path) htsmsg_add_str(e, "path", m->path);
- htsmsg_add_u32(e, "flags", m->flags);
+ htsmsg_add_u32(e, "type", m->type);
htsmsg_add_u32(e, "enabled", m->enabled);
+ if(m->name)
+ htsmsg_add_str(e, "name", m->name);
+ if(m->type == EPGGRAB_EXT) {
+ epggrab_module_ext_t *ext = (epggrab_module_ext_t*)m;
+ htsmsg_add_str(e, "path", ext->path);
+ }
htsmsg_add_msg(a, NULL, e);
}
return a;
}
+
+/* **************************************************************************
+ * Initialisation
+ * *************************************************************************/
+
+/*
+ * Initialise
+ */
+void epggrab_init ( void )
+{
+ /* Initialise modules */
+ eit_init();
+ xmltv_init();
+ pyepg_init();
+ opentv_init();
+
+ /* Load config */
+ _epggrab_load();
+
+ /* Start internal grab thread */
+ pthread_t tid;
+ pthread_attr_t tattr;
+ pthread_attr_init(&tattr);
+ pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
+ pthread_create(&tid, &tattr, _epggrab_internal_thread, NULL);
+}
+
diff --git a/src/epggrab.h b/src/epggrab.h
index 7a6cdbb6..ea95ebce 100644
--- a/src/epggrab.h
+++ b/src/epggrab.h
@@ -1,12 +1,41 @@
+/*
+ * EPG Grabber - common functions
+ * Copyright (C) 2012 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 .
+ */
+
#ifndef __EPGGRAB_H__
#define __EPGGRAB_H__
-typedef struct epggrab_module epggrab_module_t;
-
#include
-#include "channels.h"
-#include "dvb/dvb.h"
-#include "epggrab/ota.h"
+
+/* **************************************************************************
+ * Typedefs/Forward decls
+ * *************************************************************************/
+
+struct th_dvb_mux_instance;
+struct th_dvb_adapter;
+
+typedef struct epggrab_module epggrab_module_t;
+typedef struct epggrab_module_int epggrab_module_int_t;
+typedef struct epggrab_module_ext epggrab_module_ext_t;
+typedef struct epggrab_module_ota epggrab_module_ota_t;
+typedef struct epggrab_ota_mux epggrab_ota_mux_t;
+
+LIST_HEAD(epggrab_module_list, epggrab_module);
+typedef struct epggrab_module_list epggrab_module_list_t;
/* **************************************************************************
* Grabber Stats
@@ -41,14 +70,14 @@ typedef struct epggrab_channel
epggrab_module_t *mod; ///< Linked module
char *id; ///< Grabber's ID
+
char *name; ///< Channel name
- char **sname; ///< Service name's
- uint16_t *sid; ///< Service ID's
- int sid_cnt; ///< Number of service IDs
-
char *icon; ///< Channel icon
int number; ///< Channel number
+ char **sname; ///< Service name's
+ uint16_t *sid; ///< Service ID's
+
struct channel *channel; ///< Mapped channel
} epggrab_channel_t;
@@ -67,88 +96,109 @@ htsmsg_t* epggrab_channel_list ( void );
* Mutators
*/
int epggrab_channel_set_name ( epggrab_channel_t *ch, const char *name );
-int epggrab_channel_set_sid ( epggrab_channel_t *ch, const uint16_t *sid, int num );
-int epggrab_channel_set_sname ( epggrab_channel_t *ch, const char **sname );
int epggrab_channel_set_icon ( epggrab_channel_t *ch, const char *icon );
int epggrab_channel_set_number ( epggrab_channel_t *ch, int number );
-
-void epggrab_channel_updated ( epggrab_channel_t *ch );
-void epggrab_channel_link ( epggrab_channel_t *ch );
+int epggrab_channel_set_sname ( epggrab_channel_t *ch, const char **sname );
+int epggrab_channel_set_sid ( epggrab_channel_t *ch, const uint16_t *sid );
/*
- * Match the channel
+ * Updated/link
*/
+void epggrab_channel_updated ( epggrab_channel_t *ch );
/* **************************************************************************
* Grabber Modules
* *************************************************************************/
-/*
- * Grabber flags
- */
-#define EPGGRAB_MODULE_INTERNAL 0x01 ///< IP based internally run
-#define EPGGRAB_MODULE_EXTERNAL 0x02 ///< IP based externally run
-#define EPGGRAB_MODULE_OTA 0x04 ///< DVB OTA EPGs
-
/*
* Grabber base class
*/
struct epggrab_module
{
- LIST_ENTRY(epggrab_module) link; ///< Global list link
+ LIST_ENTRY(epggrab_module) link; ///< Global list link
+ enum {
+ EPGGRAB_INT,
+ EPGGRAB_EXT,
+ EPGGRAB_OTA
+ } type; ///< Grabber type
const char *id; ///< Module identifier
const char *name; ///< Module name (for display)
- const char *path; ///< Module path (for fixed config)
- const uint8_t flags; ///< Mode flag
uint8_t enabled; ///< Whether the module is enabled
- int sock; ///< Socket descriptor
- epggrab_channel_tree_t *channels; ///< Channel list
- LIST_HEAD(, epggrab_ota_mux) muxes; ///< Linked muxes
/* Enable/Disable */
- int (*enable) ( epggrab_module_t *m, uint8_t e );
-
- /* Grab/Translate/Parse */
- char* (*grab) ( epggrab_module_t *m );
- htsmsg_t* (*trans) ( epggrab_module_t *m, char *d );
- int (*parse) ( epggrab_module_t *m,
- htsmsg_t *d, epggrab_stats_t *s );
-
- /* Channel listings */
- void (*ch_add) ( epggrab_module_t *m, channel_t *ch );
- void (*ch_rem) ( epggrab_module_t *m, channel_t *ch );
- void (*ch_mod) ( epggrab_module_t *m, channel_t *ch );
-
- /* Transponder tuning */
- void (*tune) ( epggrab_module_t *m, th_dvb_mux_instance_t *tdmi );
+ int (*enable) ( void *m, uint8_t e );
};
/*
- * Default module functions
+ * Internal grabber
*/
+struct epggrab_module_int
+{
+ epggrab_module_t ; ///< Parent object
-int epggrab_module_enable_socket ( epggrab_module_t *m, uint8_t e );
-const char *epggrab_module_socket_path ( const char *id );
+ const char *path; ///< Path for the command
+ epggrab_channel_tree_t *channels; ///< Channel list
-char *epggrab_module_grab ( epggrab_module_t *m );
-htsmsg_t *epggrab_module_trans_xml ( epggrab_module_t *m, char *d );
+ /* Handle data */
+ char* (*grab) ( void *mod );
+ htsmsg_t* (*trans) ( void *mod, char *data );
+ int (*parse) ( void *mod, htsmsg_t *data, epggrab_stats_t *stat );
-void epggrab_module_channel_save
- ( epggrab_module_t *m, epggrab_channel_t *ch );
-void epggrab_module_channels_load ( epggrab_module_t *m );
-void epggrab_module_channel_add ( epggrab_module_t *m, channel_t *ch );
-void epggrab_module_channel_rem ( epggrab_module_t *m, channel_t *ch );
-void epggrab_module_channel_mod ( epggrab_module_t *m, channel_t *ch );
-
-epggrab_channel_t *epggrab_module_channel_find
- ( epggrab_module_t *mod, const char *id, int create, int *save );
+ /* Channel listings */
+ void (*ch_add) ( void *m, struct channel *ch );
+ void (*ch_rem) ( void *m, struct channel *ch );
+ void (*ch_mod) ( void *m, struct channel *ch );
+};
/*
- * Module list
+ * External grabber
*/
-LIST_HEAD(epggrab_module_list, epggrab_module);
-typedef struct epggrab_module_list epggrab_module_list_t;
+struct epggrab_module_ext
+{
+ epggrab_module_int_t ; ///< Parent object
+
+ int sock; ///< Socket descriptor
+};
+
+/*
+ * OTA / mux link
+ */
+struct epggrab_ota_mux
+{
+ LIST_ENTRY(epggrab_ota_mux) glob_link; ///< Grabber link
+ TAILQ_ENTRY(epggrab_ota_mux) reg_link; ///< List of reg'd
+ struct th_dvb_mux_instance *tdmi; ///< Mux instance
+ epggrab_module_ota_t *grab; ///< Grab instance
+
+ int timeout; ///< Time out if this long
+ int interval; ///< Re-grab this often
+
+ int is_reg; ///< Registered with mux
+
+ void *status; ///< Status information
+ enum {
+ EPGGRAB_OTA_MUX_IDLE,
+ EPGGRAB_OTA_MUX_RUNNING,
+ EPGGRAB_OTA_MUX_TIMEDOUT,
+ EPGGRAB_OTA_MUX_COMPLETE
+ } state; ///< Current state
+ time_t started; ///< Time of last start
+ time_t completed; ///< Time of last completion
+
+ void (*destroy) (epggrab_ota_mux_t *ota); ///< (Custom) destroy
+};
+
+/*
+ * Over the air grabber
+ */
+struct epggrab_module_ota
+{
+ epggrab_module_t ; ///< Parent object
+
+ /* Transponder tuning */
+ void (*start) ( epggrab_module_ota_t *m, struct th_dvb_mux_instance *tdmi );
+};
/*
* Access the Module list
@@ -157,38 +207,42 @@ epggrab_module_t* epggrab_module_find_by_id ( const char *id );
htsmsg_t* epggrab_module_list ( void );
/* **************************************************************************
- * Configuration
+ * Setup/Configuration
* *************************************************************************/
/*
* Configuration
*/
-extern pthread_mutex_t epggrab_mutex;
-extern uint32_t epggrab_interval;
-extern epggrab_module_t* epggrab_module;
-extern uint32_t epggrab_channel_rename;
-extern uint32_t epggrab_channel_renumber;
-extern uint32_t epggrab_channel_reicon;
+extern epggrab_module_list_t epggrab_modules;
+extern pthread_mutex_t epggrab_mutex;
+extern uint32_t epggrab_interval;
+extern epggrab_module_int_t* epggrab_module;
+extern uint32_t epggrab_channel_rename;
+extern uint32_t epggrab_channel_renumber;
+extern uint32_t epggrab_channel_reicon;
/*
- * Update
+ * Set configuration
*/
int epggrab_set_interval ( uint32_t interval );
-int epggrab_set_module ( epggrab_module_t *module );
+int epggrab_set_module ( epggrab_module_t *mod );
int epggrab_set_module_by_id ( const char *id );
int epggrab_set_channel_rename ( uint32_t e );
int epggrab_set_channel_renumber ( uint32_t e );
int epggrab_set_channel_reicon ( uint32_t e );
-int epggrab_enable_module ( epggrab_module_t *module, uint8_t e );
+int epggrab_enable_module ( epggrab_module_t *mod, uint8_t e );
int epggrab_enable_module_by_id ( const char *id, uint8_t e );
+
+/*
+ * Load/Save
+ */
+void epggrab_init ( void );
void epggrab_save ( void );
/* **************************************************************************
* Global Functions
* *************************************************************************/
-void epggrab_init ( void );
-
/*
* Channel handling
*/
@@ -199,6 +253,21 @@ void epggrab_channel_mod ( struct channel *ch );
/*
* Transport handling
*/
-void epggrab_tune ( th_dvb_mux_instance_t *tdmi );
+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 );
+
+/*
+ * Re-schedule
+ */
+void epggrab_resched ( void );
#endif /* __EPGGRAB_H__ */
+
+/* **************************************************************************
+ * Editor
+ *
+ * vim:sts=2:ts=2:sw=2:et
+ * *************************************************************************/
diff --git a/src/epggrab/channel.c b/src/epggrab/channel.c
new file mode 100644
index 00000000..8b3b21eb
--- /dev/null
+++ b/src/epggrab/channel.c
@@ -0,0 +1,275 @@
+/*
+ * EPG Grabber - channel functions
+ * Copyright (C) 2012 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 .
+ */
+
+#include
+#include
+
+#include "tvheadend.h"
+#include "settings.h"
+#include "htsmsg.h"
+#include "channels.h"
+#include "service.h"
+#include "epg.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
+
+#if 0
+static int _ch_id_cmp ( void *a, void *b )
+{
+ return strcmp(((epggrab_channel_t*)a)->id,
+ ((epggrab_channel_t*)b)->id);
+}
+#endif
+
+int epggrab_channel_link ( epggrab_channel_t *ec, channel_t *ch )
+{
+ service_t *sv;
+ int match = 0, i;
+
+ if (!ec || !ch) return 0;
+ if (ec->channel) return 0;
+
+ if (ec->name && !strcmp(ec->name, ch->ch_name))
+ match = 1;
+ else {
+ LIST_FOREACH(sv, &ch->ch_services, s_ch_link) {
+ if (ec->sid) {
+ i = 0;
+ while (ec->sid[i]) {
+ if (sv->s_dvb_service_id == ec->sid[i]) {
+ match = 1;
+ break;
+ }
+ i++;
+ }
+ }
+ if (!match && ec->sname) {
+ i = 0;
+ while (ec->sname[i]) {
+ if (!strcmp(ec->sname[i], sv->s_svcname)) {
+ match = 1;
+ break;
+ }
+ i++;
+ }
+ }
+ if (match) break;
+ }
+ }
+
+ if (match) {
+ tvhlog(LOG_INFO, ec->mod->id, "linking %s to %s",
+ ec->id, ch->ch_name);
+ ec->channel = ch;
+ if (ec->name && epggrab_channel_rename)
+ channel_rename(ch, ec->name);
+ if (ec->icon && epggrab_channel_reicon)
+ channel_set_icon(ch, ec->icon);
+ if (ec->number>0 && epggrab_channel_renumber)
+ channel_set_number(ch, ec->number);
+ }
+
+ return match;
+}
+
+int epggrab_channel_set_name ( epggrab_channel_t *ec, const char *name )
+{
+ int save = 0;
+ if (!ec || !name) return 0;
+ if (!ec->name || strcmp(ec->name, name)) {
+ if (ec->name) free(ec->name);
+ ec->name = strdup(name);
+ if (ec->channel) channel_rename(ec->channel, name);
+ save = 1;
+ }
+ return save;
+}
+
+int epggrab_channel_set_sid
+ ( epggrab_channel_t *ec, const uint16_t *sid )
+{
+#if 0
+ int save = 0, i = 0, num = 0;
+ if ( !ec || !sid ) return 0;
+ if (!ec->sid) save = 1;
+ else {
+
+ for (i = 0; i < num; i++ ) {
+ if (sid[i] != ec->sid[i]) {
+ save = 1;
+ break;
+ }
+ }
+ }
+ if (save) {
+ if (ec->sid) free(ec->sid);
+ ec->sid = calloc(num, sizeof(uint16_t));
+ for (i = 0; i < num; i++ ) {
+ ec->sid[i] = sid[i];
+ }
+ ec->sid_cnt = num;
+ }
+ return save;
+#endif
+ return 0;
+}
+
+int epggrab_channel_set_sname ( epggrab_channel_t *ec, const char **sname )
+{
+ int save = 0, i = 0;
+ if ( !ec || !sname ) return 0;
+ if (!ec->sname) save = 1;
+ else {
+ while ( ec->sname[i] && sname[i] ) {
+ if (strcmp(ec->sname[i], sname[i])) {
+ save = 1;
+ break;
+ }
+ i++;
+ }
+ if (!save && (ec->sname[i] || sname[i])) save = 1;
+ }
+ if (save) {
+ if (ec->sname) {
+ i = 0;
+ while (ec->sname[i])
+ free(ec->sname[i++]);
+ free(ec->sname);
+ }
+ i = 0;
+ while (sname[i++]);
+ ec->sname = calloc(i+1, sizeof(char*));
+ i = 0;
+ while (sname[i]) {
+ ec->sname[i] = strdup(sname[i]);
+ i++;
+ }
+ }
+ return save;
+}
+
+int epggrab_channel_set_icon ( epggrab_channel_t *ec, const char *icon )
+{
+ int save = 0;
+ if (!ec->icon || strcmp(ec->icon, icon) ) {
+ if (!ec | !icon) return 0;
+ if (ec->icon) free(ec->icon);
+ ec->icon = strdup(icon);
+ if (ec->channel) channel_set_icon(ec->channel, icon);
+ save = 1;
+ }
+ return save;
+}
+
+int epggrab_channel_set_number ( epggrab_channel_t *ec, int number )
+{
+ int save = 0;
+ if (!ec || (number <= 0)) return 0;
+ if (ec->number != number) {
+ ec->number = number;
+ if (ec->channel) channel_set_number(ec->channel, number);
+ save = 1;
+ }
+ return save;
+}
+
+
+void epggrab_channel_updated ( epggrab_channel_t *ec )
+{
+ //epggrab_channel_link(ec);
+ epggrab_module_ch_save(ec->mod, ec);
+}
+
+#if 0
+void epggrab_channel_link ( epggrab_channel_t *ec )
+{
+ channel_t *ch;
+
+ if (!ec) return;
+
+ /* Link */
+ if (!ec->channel) {
+ RB_FOREACH(ch, &channel_name_tree, ch_name_link) {
+ if (_ch_link(ec, ch)) break;
+ }
+ }
+}
+#endif
+
+htsmsg_t *epggrab_channel_list ( void )
+{
+#if 0
+ char name[100];
+ epggrab_module_t *mod;
+ epggrab_channel_t *ec;
+ htsmsg_t *e, *m;
+ m = htsmsg_create_list();
+ LIST_FOREACH(mod, &epggrab_modules, link) {
+ if (mod->enabled && mod->channels) {
+ RB_FOREACH(ec, mod->channels, link) {
+ e = htsmsg_create_map();
+ htsmsg_add_str(e, "module", mod->id);
+ htsmsg_add_str(e, "id", ec->id);
+ sprintf(name, "%s: %s", mod->name, ec->name);
+ htsmsg_add_str(e, "name", name);
+ htsmsg_add_msg(m, NULL, e);
+ }
+ }
+ }
+ return m;
+#endif
+ return NULL;
+}
+
+void epggrab_channel_add ( channel_t *ch )
+{
+#if 0
+ epggrab_module_t *m;
+ LIST_FOREACH(m, &epggrab_modules, link) {
+ if (m->ch_add) m->ch_add(m, ch);
+ }
+#endif
+}
+
+void epggrab_channel_rem ( channel_t *ch )
+{
+#if 0
+ epggrab_module_t *m;
+ LIST_FOREACH(m, &epggrab_modules, link) {
+ if (m->ch_rem) m->ch_rem(m, ch);
+ }
+#endif
+}
+
+void epggrab_channel_mod ( channel_t *ch )
+{
+#if 0
+ epggrab_module_t *m;
+ LIST_FOREACH(m, &epggrab_modules, link) {
+ if (m->ch_mod) m->ch_mod(m, ch);
+ }
+#endif
+}
+
+epggrab_channel_t *epggrab_channel_find
+ ( epggrab_channel_tree_t *tree, const char *id, int create, int *save )
+{
+ // TODO
+ return NULL;
+}
+
diff --git a/src/epggrab/eit.h b/src/epggrab/eit.h
deleted file mode 100644
index c278718b..00000000
--- a/src/epggrab/eit.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Electronic Program Guide - eit grabber
- * Copyright (C) 2012 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 .
- */
-
-#ifndef EPGGRAB_EIT_H
-#define EPGGRAB_EIT_H
-
-#include "epggrab.h"
-
-void eit_init ( epggrab_module_list_t *list );
-void eit_load ( void );
-
-#endif
diff --git a/src/epggrab/module.c b/src/epggrab/module.c
new file mode 100644
index 00000000..092f7d99
--- /dev/null
+++ b/src/epggrab/module.c
@@ -0,0 +1,450 @@
+/*
+ * EPG Grabber - module functions
+ * Copyright (C) 2012 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 .
+ */
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include "tvheadend.h"
+#include "settings.h"
+#include "htsmsg.h"
+#include "htsmsg_xml.h"
+#include "service.h"
+#include "channels.h"
+#include "spawn.h"
+#include "file.h"
+#include "epg.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
+
+/* **************************************************************************
+ * Generic module routines
+ * *************************************************************************/
+
+epggrab_module_t *epggrab_module_create
+ ( epggrab_module_t *skel, const char *id, const char *name )
+{
+ assert(skel);
+
+ /* Setup */
+ skel->id = strdup(id);
+ skel->name = strdup(name);
+
+ /* Insert */
+ assert(!epggrab_module_find_by_id(id));
+ LIST_INSERT_HEAD(&epggrab_modules, skel, link);
+
+ return skel;
+}
+
+/* **************************************************************************
+ * Channel related routines
+ * *************************************************************************/
+
+void epggrab_module_ch_save ( void *_m, epggrab_channel_t *ch )
+{
+ int i;
+ htsmsg_t *m = htsmsg_create_map();
+ htsmsg_t *a;
+ epggrab_module_t *mod = _m;
+
+ if (ch->name)
+ htsmsg_add_str(m, "name", ch->name);
+ if (ch->icon)
+ htsmsg_add_str(m, "icon", ch->icon);
+ if (ch->channel)
+ htsmsg_add_u32(m, "channel", ch->channel->ch_id);
+ if (ch->sid) {
+ a = htsmsg_create_list();
+ i = 0;
+ while (ch->sid[i]) {
+ htsmsg_add_u32(a, NULL, ch->sid[i]);
+ i++;
+ }
+ htsmsg_add_msg(m, "sid", a);
+ }
+ if (ch->sname) {
+ a = htsmsg_create_list();
+ i = 0;
+ while (ch->sname[i]) {
+ htsmsg_add_str(a, NULL, ch->sname[i]);
+ i++;
+ }
+ htsmsg_add_msg(m, "sname", a);
+ }
+ if (ch->number)
+ htsmsg_add_u32(m, "number", ch->number);
+
+ hts_settings_save(m, "epggrab/%s/channels/%s", mod->id, ch->id);
+}
+
+void epggrab_module_ch_add ( void *m, channel_t *ch )
+{
+ epggrab_channel_t *egc;
+ epggrab_module_int_t *mod = m;
+ RB_FOREACH(egc, mod->channels, link) {
+ if (epggrab_channel_link(egc, ch)) {
+ epggrab_module_ch_save(mod, egc);
+ break;
+ }
+ }
+}
+
+void epggrab_module_ch_rem ( void *m, channel_t *ch )
+{
+ epggrab_channel_t *egc;
+ epggrab_module_int_t *mod = m;
+ RB_FOREACH(egc, mod->channels, link) {
+ if (egc->channel == ch) {
+ egc->channel = NULL;
+ epggrab_module_ch_save(mod, egc);
+ break;
+ }
+ }
+}
+
+void epggrab_module_ch_mod ( void *mod, channel_t *ch )
+{
+ return epggrab_module_ch_add(mod, ch);
+}
+
+
+#if 0
+
+static void epggrab_module_ch_load
+ ( epggrab_module_t *mod, htsmsg_t *m, const char *id )
+{
+ int save = 0, i;
+ const char *str;
+ uint32_t u32;
+ htsmsg_t *a;
+ htsmsg_field_t *f;
+
+ epggrab_channel_t *ch = epggrab_module_channel_find(mod, id, 1, &save);
+
+ if ((str = htsmsg_get_str(m, "name")))
+ ch->name = strdup(str);
+ if ((str = htsmsg_get_str(m, "icon")))
+ ch->icon = strdup(str);
+ if ((a = htsmsg_get_list(m, "sid"))) {
+ i = 0;
+ HTSMSG_FOREACH(f, a) i++;
+ ch->sid_cnt = i;
+ ch->sid = calloc(i, sizeof(uint16_t));
+ i = 0;
+ HTSMSG_FOREACH(f, a) {
+ ch->sid[i] = (uint16_t)f->hmf_s64;
+ i++;
+ }
+ }
+ if ((a = htsmsg_get_list(m, "sname"))) {
+ i = 0;
+ HTSMSG_FOREACH(f, a) i++;
+ ch->sname = calloc(i+1, sizeof(char*));
+ i = 0;
+ HTSMSG_FOREACH(f, a) {
+ ch->sname[i] = strdup(f->hmf_str);
+ i++;
+ }
+ }
+ if(!htsmsg_get_u32(m, "number", &u32))
+ ch->number = u32;
+
+ if (!htsmsg_get_u32(m, "channel", &u32))
+ ch->channel = channel_find_by_identifier(u32);
+}
+
+void epggrab_module_channels_load ( epggrab_module_t *mod )
+{
+ htsmsg_t *m, *e;
+ htsmsg_field_t *f;
+
+ if ((m = hts_settings_load("epggrab/%s/channels", mod->id))) {
+ HTSMSG_FOREACH(f, m) {
+ if ((e = htsmsg_get_map_by_field(f)))
+ epggrab_module_channel_load(mod, e, f->hmf_name);
+ }
+ htsmsg_destroy(m);
+ }
+}
+
+epggrab_channel_t *epggrab_module_ch_find
+ ( epggrab_module_t *mod, const char *id, int create, int *save )
+{
+ epggrab_channel_t *ec;
+ static epggrab_channel_t *skel = NULL;
+
+ if (!mod || !mod->channels ) return NULL;
+
+ if ( !skel ) skel = calloc(1, sizeof(epggrab_channel_t));
+ skel->id = (char*)id;
+ skel->mod = mod;
+
+ /* Find */
+ if (!create) {
+ ec = RB_FIND(mod->channels, skel, link, _ch_id_cmp);
+
+ /* Create (if required) */
+ } else {
+ ec = RB_INSERT_SORTED(mod->channels, skel, link, _ch_id_cmp);
+ if ( ec == NULL ) {
+ skel->id = strdup(skel->id);
+ ec = skel;
+ skel = NULL;
+ *save = 1;
+ }
+ }
+
+ return ec;
+}
+#endif
+
+/* **************************************************************************
+ * Internal module routines
+ * *************************************************************************/
+
+epggrab_module_int_t *epggrab_module_int_create
+ ( epggrab_module_int_t *skel,
+ const char *id, const char *name, const char *path,
+ char* (*grab) (void*m),
+ int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta),
+ htsmsg_t* (*trans) (void *mod, char *data),
+ epggrab_channel_tree_t *channels )
+{
+ /* Allocate data */
+ if (!skel) skel = calloc(1, sizeof(epggrab_module_int_t));
+
+ /* Pass through */
+ epggrab_module_create((epggrab_module_t*)skel, id, name);
+
+ /* Int data */
+ skel->type = EPGGRAB_INT;
+ skel->path = strdup(path);
+ skel->channels = channels;
+ skel->grab = grab ?: epggrab_module_grab_spawn;
+ skel->trans = trans ?: epggrab_module_trans_xml;
+ skel->parse = parse;
+ if (channels) {
+ skel->ch_add = epggrab_module_ch_add;
+ skel->ch_rem = epggrab_module_ch_rem;
+ skel->ch_mod = epggrab_module_ch_mod;
+ }
+
+ return skel;
+}
+
+char *epggrab_module_grab_spawn ( void *m )
+{
+ int outlen;
+ char *outbuf;
+ epggrab_module_int_t *mod = m;
+
+ /* Debug */
+ tvhlog(LOG_INFO, mod->id, "grab %s", mod->path);
+
+ /* Grab */
+ outlen = spawn_and_store_stdout(mod->path, NULL, &outbuf);
+ if ( outlen < 1 ) {
+ tvhlog(LOG_ERR, "pyepg", "no output detected");
+ return NULL;
+ }
+
+ return outbuf;
+}
+
+
+
+htsmsg_t *epggrab_module_trans_xml ( void *m, char *c )
+{
+ htsmsg_t *ret;
+ char errbuf[100];
+
+ if (!c) return NULL;
+
+ /* Extract */
+ ret = htsmsg_xml_deserialize(c, errbuf, sizeof(errbuf));
+ if (!ret)
+ tvhlog(LOG_ERR, "pyepg", "htsmsg_xml_deserialize error %s", errbuf);
+ return ret;
+}
+
+/* **************************************************************************
+ * External module routines
+ * *************************************************************************/
+
+/*
+ * Socket handler
+ */
+static void _epggrab_socket_handler ( epggrab_module_ext_t *mod, int s )
+{
+ size_t outlen;
+ char *outbuf;
+ time_t tm1, tm2;
+ htsmsg_t *data = NULL;
+
+ /* Grab/Translate */
+ time(&tm1);
+ outlen = file_readall(s, &outbuf);
+ if (outlen) data = mod->trans(mod, outbuf);
+ time(&tm2);
+
+ /* Process */
+ if ( data ) {
+ tvhlog(LOG_INFO, mod->id, "grab took %d seconds", tm2 - tm1);
+ epggrab_module_parse(mod, data);
+
+ /* Failed */
+ } else {
+ tvhlog(LOG_ERR, mod->id, "failed to read data");
+ }
+}
+
+
+/*
+ * External (socket) grab thread
+ */
+static void *_epggrab_socket_thread ( void *p )
+{
+ int s;
+ epggrab_module_ext_t *mod = (epggrab_module_ext_t*)p;
+ tvhlog(LOG_INFO, mod->id, "external socket enabled");
+
+ while ( mod->enabled && mod->sock ) {
+ tvhlog(LOG_DEBUG, mod->id, "waiting for connection");
+ s = accept(mod->sock, NULL, NULL);
+ if (s <= 0) continue;
+ tvhlog(LOG_DEBUG, mod->id, "got connection %d", s);
+ _epggrab_socket_handler(mod, s);
+ }
+ tvhlog(LOG_DEBUG, mod->id, "terminated");
+ return NULL;
+}
+
+/*
+ * Enable socket module
+ */
+int epggrab_module_enable_socket ( void *m, uint8_t e )
+{
+ pthread_t tid;
+ pthread_attr_t tattr;
+ struct sockaddr_un addr;
+ epggrab_module_ext_t *mod = (epggrab_module_ext_t*)m;
+ assert(mod->type == EPGGRAB_EXT);
+
+ /* Ignore */
+ if ( mod->enabled == e ) return 0;
+
+ /* Disable */
+ if (!e) {
+ shutdown(mod->sock, SHUT_RDWR);
+ close(mod->sock);
+ unlink(mod->path);
+ mod->sock = 0;
+
+ /* Enable */
+ } else {
+ unlink(mod->path); // just in case!
+
+ mod->sock = socket(AF_UNIX, SOCK_STREAM, 0);
+ assert(mod->sock);
+
+ memset(&addr, 0, sizeof(struct sockaddr_un));
+ addr.sun_family = AF_UNIX;
+ strncpy(addr.sun_path, mod->path, 100);
+ if ( bind(mod->sock, (struct sockaddr*)&addr,
+ sizeof(struct sockaddr_un)) != 0 ) {
+ tvhlog(LOG_ERR, mod->id, "failed to bind socket");
+ close(mod->sock);
+ mod->sock = 0;
+ return 0;
+ }
+
+ if ( listen(mod->sock, 5) != 0 ) {
+ tvhlog(LOG_ERR, mod->id, "failed to listen on socket");
+ close(mod->sock);
+ mod->sock = 0;
+ return 0;
+ }
+
+ tvhlog(LOG_DEBUG, mod->id, "starting socket thread");
+ pthread_attr_init(&tattr);
+ pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
+ pthread_create(&tid, &tattr, _epggrab_socket_thread, mod);
+ }
+ mod->enabled = e;
+ return 1;
+}
+
+/*
+ * Create a module
+ */
+epggrab_module_ext_t *epggrab_module_ext_create
+ ( epggrab_module_ext_t *skel,
+ const char *id, const char *name, const char *sockid,
+ int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta),
+ htsmsg_t* (*trans) (void *mod, char *data),
+ epggrab_channel_tree_t *channels )
+{
+ char path[512];
+
+ /* Allocate data */
+ if (!skel) skel = calloc(1, sizeof(epggrab_module_ext_t));
+
+ /* Pass through */
+ snprintf(path, 512, "%s/epggrab/%s.sock",
+ hts_settings_get_root(), sockid);
+ epggrab_module_int_create((epggrab_module_int_t*)skel,
+ id, name, path,
+ NULL, parse, trans,
+ channels);
+
+ /* Local */
+ skel->type = EPGGRAB_EXT;
+ skel->enable = epggrab_module_enable_socket;
+
+ return skel;
+}
+
+/* **************************************************************************
+ * OTA module functions
+ * *************************************************************************/
+
+epggrab_module_ota_t *epggrab_module_ota_create
+ ( epggrab_module_ota_t *skel,
+ const char *id, const char *name,
+ void (*start) (epggrab_module_ota_t*m,
+ struct th_dvb_mux_instance *tdmi),
+ int (*enable) (void *m, uint8_t e ),
+ epggrab_channel_tree_t *channels )
+{
+ if (!skel) skel = calloc(1, sizeof(epggrab_module_ota_t));
+
+ /* Pass through */
+ epggrab_module_create((epggrab_module_t*)skel, id, name);
+
+ /* Setup */
+ skel->type = EPGGRAB_OTA;
+ skel->enable = enable;
+ skel->start = start;
+
+ return skel;
+}
+
diff --git a/src/epggrab/eit.c b/src/epggrab/module/eit.c
similarity index 86%
rename from src/epggrab/eit.c
rename to src/epggrab/module/eit.c
index 5c182918..502048ed 100644
--- a/src/epggrab/eit.c
+++ b/src/epggrab/module/eit.c
@@ -23,9 +23,18 @@
#include "dvb/dvb_support.h"
#include "service.h"
#include "epg.h"
-#include "epggrab/eit.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
-static epggrab_module_t _eit_mod;
+/* ************************************************************************
+ * Status handling
+ * ***********************************************************************/
+
+typedef struct eit_status
+{
+ int tid;
+ int sec;
+} eit_status_t;
/* ************************************************************************
* Processing
@@ -112,12 +121,13 @@ static int _eit_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t tableid, void *opaque )
{
- th_dvb_mux_instance_t *otdmi = tdmi;
+ epggrab_ota_mux_t *ota = (epggrab_ota_mux_t*)opaque;
th_dvb_adapter_t *tda;
service_t *svc;
channel_t *ch;
epg_broadcast_t *ebc;
epg_episode_t *ee;
+ eit_status_t *sta;
int resched = 0, save = 0, save2 = 0, dllen, dtag, dlen;
uint16_t tsid, sid, eid;
uint8_t bw, hd, ws, ad, ds, st;
@@ -129,14 +139,26 @@ static int _eit_callback
char desc[5000];
htsmsg_t *extra;
- /* Disabled */
- if(!_eit_mod.enabled) return 0;
-
/* Invalid */
if(tableid < 0x4e || tableid > 0x6f || len < 11)
return -1;
- /* Skip */
+ /* Already complete */
+ if (epggrab_ota_is_complete(ota)) return 0;
+
+ /* Started */
+ sta = ota->status;
+ if (epggrab_ota_begin(ota)) {
+ sta->tid = tableid;
+ sta->sec = ptr[3];
+
+ /* Complete */
+ } else if (sta->tid == tableid && sta->sec == ptr[3]) {
+ epggrab_ota_complete(ota);
+ return 0;
+ }
+
+ /* Don't process */
if((ptr[2] & 1) == 0)
return 0;
@@ -162,12 +184,12 @@ static int _eit_callback
/* Ignore (disabled) */
if (!svc->s_dvb_eit_enable) return 0;
- /* Register interest */
+ /* Register as interesting */
if (tableid < 0x50)
- epggrab_ota_register(&_eit_mod, otdmi, 20, 0);
+ epggrab_ota_register(ota, 20, 0);
else
- epggrab_ota_register(&_eit_mod, otdmi, 40, 0);
-
+ epggrab_ota_register(ota, 40, 0);
+
/* Up to date */
#if TODO_INCLUDE_EIT_VER_CHECK
ver = ptr[2] >> 1 & 0x1f;
@@ -198,7 +220,7 @@ static int _eit_callback
continue;
}
- /* Mark re-schedule detect */
+ /* Mark re-schedule detect (only now/next) */
if (save2 && tableid < 0x50) resched = 1;
/* Process tags */
@@ -346,9 +368,8 @@ static int _eit_callback
}
/* Update EPG */
- if (resched) tvhlog(LOG_DEBUG, "eit", "alert grabbers to resched");
- // TODO: handle the reschedule
- if (save) epg_updated();
+ if (resched) epggrab_resched();
+ if (save) epg_updated();
return 0;
}
@@ -357,19 +378,21 @@ static int _eit_callback
* Module Setup
* ***********************************************************************/
-static void _eit_tune ( epggrab_module_t *m, th_dvb_mux_instance_t *tdmi )
+static void _eit_start
+ ( epggrab_module_ota_t *m, th_dvb_mux_instance_t *tdmi )
{
- if (_eit_mod.enabled)
- tdt_add(tdmi, NULL, _eit_callback, NULL, "eit", TDT_CRC, 0x12, NULL);
+ epggrab_ota_mux_t *ota;
+ if (!m->enabled) return;
+ if (!(ota = epggrab_ota_create(m, tdmi))) return;
+ if (!ota->status)
+ ota->status = calloc(1, sizeof(eit_status_t));
+ tdt_add(tdmi, NULL, _eit_callback, ota, "eit", TDT_CRC, 0x12, NULL);
}
-void eit_init ( epggrab_module_list_t *list )
+void eit_init ( void )
{
- _eit_mod.id = strdup("eit");
- _eit_mod.name = strdup("EIT: On-Air Grabber");
- _eit_mod.tune = _eit_tune;
- *((uint8_t*)&_eit_mod.flags) = EPGGRAB_MODULE_OTA;
- LIST_INSERT_HEAD(list, &_eit_mod, link);
+ epggrab_module_ota_create(NULL, "eit", "EIT: DVB Grabber",
+ _eit_start, NULL, NULL);
}
void eit_load ( void )
diff --git a/src/epggrab/opentv.c b/src/epggrab/module/opentv.c
similarity index 74%
rename from src/epggrab/opentv.c
rename to src/epggrab/module/opentv.c
index 40b38f4f..71b98222 100644
--- a/src/epggrab/opentv.c
+++ b/src/epggrab/module/opentv.c
@@ -25,8 +25,8 @@
#include "channels.h"
#include "huffman.h"
#include "epg.h"
-#include "epggrab/ota.h"
-#include "epggrab/opentv.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
#include "subscriptions.h"
#include "streaming.h"
#include "service.h"
@@ -35,10 +35,61 @@
static epggrab_channel_tree_t _opentv_channels;
-static void _opentv_tune
- ( epggrab_module_t *m, th_dvb_mux_instance_t *tdmi );
-static int _opentv_enable
- ( epggrab_module_t *m, uint8_t e );
+/* ************************************************************************
+ * Status monitoring
+ * ***********************************************************************/
+
+/* Internal event structure */
+typedef struct opentv_event
+{
+ RB_ENTRY(opentv_event) ev_link; ///< List of partial events
+ uint16_t cid; ///< Channel ID
+ uint16_t eid; ///< Events ID
+ time_t start; ///< Start time
+ time_t stop; ///< Event stop time
+ char *title; ///< Event title
+ char *summary; ///< Event summary
+ char *desc; ///< Event description
+ uint8_t cat; ///< Event category
+ uint16_t series; ///< Series (link) reference
+
+ uint8_t type; ///< 0x1=title, 0x2=summary
+} opentv_event_t;
+
+typedef struct opentv_pid_status
+{
+ LIST_ENTRY(opentv_pid_status) link;
+ int pid;
+ enum {
+ OPENTV_PID_INIT,
+ OPENTV_PID_STARTED,
+ OPENTV_PID_COMPLETE
+ } state;
+ uint8_t start[20];
+} opentv_pid_status_t;
+
+typedef struct opentv_status
+{
+ int begbat;
+ int endbat;
+ LIST_HEAD(, opentv_pid_status) pids;
+ RB_HEAD(, opentv_event) events;
+} opentv_status_t;
+
+static opentv_pid_status_t *_opentv_get_pid_status
+ ( opentv_status_t *sta, int pid )
+{
+ opentv_pid_status_t *p;
+ LIST_FOREACH(p, &sta->pids, link) {
+ if (p->pid == pid) break;
+ }
+ if (!p) {
+ p = calloc(1, sizeof(opentv_pid_status_t));
+ p->pid = pid;
+ LIST_INSERT_HEAD(&sta->pids, p, link);
+ }
+ return p;
+}
/* ************************************************************************
* Data structures
@@ -47,19 +98,6 @@ static int _opentv_enable
#define OPENTV_SCAN_MAX 600 // 10min max scan period
#define OPENTV_SCAN_PER 3600 // 1hour interval
-/* Data carousel status */
-typedef struct opentv_status
-{
- LIST_ENTRY(opentv_status) link;
- int pid;
- enum {
- OPENTV_STA_INIT,
- OPENTV_STA_STARTED,
- OPENTV_STA_COMPLETE
- } status;
- uint8_t start[20];
-} opentv_status_t;
-
/* Huffman dictionary */
typedef struct opentv_dict
{
@@ -80,10 +118,6 @@ typedef struct opentv_module_t
int *title;
int *summary;
opentv_dict_t *dict;
-
- int endbat;
- int begbat;
- LIST_HEAD(, opentv_status) status;
} opentv_module_t;
@@ -108,6 +142,7 @@ static opentv_dict_t *_opentv_dict_find ( const char *id )
* Module functions
* ***********************************************************************/
+#if 0
static opentv_status_t *_opentv_module_get_status
( opentv_module_t *mod, int pid )
{
@@ -121,133 +156,7 @@ static opentv_status_t *_opentv_module_get_status
}
return sta;
}
-
-/* ************************************************************************
- * Configuration loading
- * ***********************************************************************/
-
-static int* _pid_list_to_array ( htsmsg_t *m, opentv_module_t *mod )
-{
- int i = 1;
- int *ret;
- htsmsg_field_t *f;
- HTSMSG_FOREACH(f, m)
- if (f->hmf_s64) i++;
- ret = calloc(i, sizeof(int));
- i = 0;
- HTSMSG_FOREACH(f, m)
- if (f->hmf_s64) {
- ret[i] = (int)f->hmf_s64;
- if (mod) (void)_opentv_module_get_status(mod, ret[i]);
- i++;
- }
- return ret;
-}
-
-static int _opentv_dict_load_one ( const char *id, htsmsg_t *m )
-{
- opentv_dict_t *dict = calloc(1, sizeof(opentv_dict_t));
- dict->id = (char*)id;
- if (RB_INSERT_SORTED(&_opentv_dicts, dict, h_link, _dict_cmp)) {
- tvhlog(LOG_DEBUG, "opentv", "ignore duplicate dictionary %s", id);
- free(dict);
- return 0;
- } else {
- dict->codes = huffman_tree_build(m);
- if (!dict->codes) {
- RB_REMOVE(&_opentv_dicts, dict, h_link);
- free(dict);
- return -1;
- } else {
- dict->id = strdup(id);
- return 1;
- }
- }
-}
-
-static void _opentv_dict_load ( htsmsg_t *m )
-{
- int r;
- htsmsg_t *e;
- htsmsg_field_t *f;
- HTSMSG_FOREACH(f, m) {
- if ((e = htsmsg_get_list(m, f->hmf_name))) {
- if ((r = _opentv_dict_load_one(f->hmf_name, e))) {
- if (r > 0)
- tvhlog(LOG_INFO, "opentv", "dictionary %s loaded", f->hmf_name);
- else
- tvhlog(LOG_WARNING, "opentv", "dictionary %s failed", f->hmf_name);
- }
- }
- }
- htsmsg_destroy(m);
-}
-
-static int _opentv_prov_load_one
- ( const char *id, htsmsg_t *m, epggrab_module_list_t *list )
-{
- char buf[100];
- htsmsg_t *cl, *tl, *sl;
- uint32_t tsid, sid, nid;
- const char *str, *name;
- opentv_dict_t *dict;
- static opentv_module_t *mod = NULL;
-
- /* Check config */
- if (!(name = htsmsg_get_str(m, "name"))) return -1;
- if (!(str = htsmsg_get_str(m, "dict"))) return -1;
- if (!(dict = _opentv_dict_find(str))) return -1;
- if (!(cl = htsmsg_get_list(m, "channel"))) return -1;
- if (!(tl = htsmsg_get_list(m, "title"))) return -1;
- if (!(sl = htsmsg_get_list(m, "summary"))) return -1;
- if (htsmsg_get_u32(m, "nid", &nid)) return -1;
- if (htsmsg_get_u32(m, "tsid", &tsid)) return -1;
- if (htsmsg_get_u32(m, "sid", &sid)) return -1;
-
- /* Exists */
- sprintf(buf, "opentv-%s", id);
- if (epggrab_module_find_by_id(buf)) return 0;
-
- /* Create module */
- mod = calloc(1, sizeof(opentv_module_t));
- mod->id = strdup(buf);
- sprintf(buf, "OpenTV: %s", name);
- mod->name = strdup(buf);
- mod->enable = _opentv_enable;
- mod->tune = _opentv_tune;
- mod->channels = &_opentv_channels;
- *((uint8_t*)&mod->flags) = EPGGRAB_MODULE_OTA;
- LIST_INSERT_HEAD(list, ((epggrab_module_t*)mod), link);
-
- /* Add provider details */
- mod->dict = dict;
- mod->nid = nid;
- mod->tsid = tsid;
- mod->sid = sid;
- mod->channel = _pid_list_to_array(cl, NULL);
- mod->title = _pid_list_to_array(tl, mod);
- mod->summary = _pid_list_to_array(sl, mod);
-
- return 1;
-}
-
-static void _opentv_prov_load ( htsmsg_t *m, epggrab_module_list_t *list )
-{
- int r;
- htsmsg_t *e;
- htsmsg_field_t *f;
- HTSMSG_FOREACH(f, m) {
- if ((e = htsmsg_get_map_by_field(f))) {
- if ((r = _opentv_prov_load_one(f->hmf_name, e, list))) {
- if (r > 0)
- tvhlog(LOG_INFO, "opentv", "provider %s loaded", f->hmf_name);
- else
- tvhlog(LOG_WARNING, "opentv", "provider %s failed", f->hmf_name);
- }
- }
- }
- htsmsg_destroy(m);
-}
+#endif
/* ************************************************************************
* EPG Object wrappers
@@ -256,9 +165,9 @@ static void _opentv_prov_load ( htsmsg_t *m, epggrab_module_list_t *list )
static epggrab_channel_t *_opentv_find_epggrab_channel
( opentv_module_t *mod, int cid, int create, int *save )
{
- char chid[32];
- sprintf(chid, "%s-%d", mod->id, cid);
- return epggrab_module_channel_find((epggrab_module_t*)mod, chid, create, save);
+// char chid[32];
+// sprintf(chid, "%s-%d", mod->id, cid);
+ return NULL;//return epggrab_module_channel_find((epggrab_module_t*)mod, chid, create, save);
}
static epg_season_t *_opentv_find_season
@@ -303,26 +212,6 @@ static channel_t *_opentv_find_channel ( int tsid, int sid )
#define OPENTV_TITLE 0x01
#define OPENTV_SUMMARY 0x02
-/* Internal event structure */
-typedef struct opentv_event
-{
- RB_ENTRY(opentv_event) ev_link; ///< List of partial events
- uint16_t cid; ///< Channel ID
- uint16_t eid; ///< Events ID
- time_t start; ///< Start time
- time_t stop; ///< Event stop time
- char *title; ///< Event title
- char *summary; ///< Event summary
- char *desc; ///< Event description
- uint8_t cat; ///< Event category
- uint16_t series; ///< Series (link) reference
-
- uint8_t type; ///< 0x1=title, 0x2=summary
-} opentv_event_t;
-
-/* List of partial events */
-RB_HEAD(, opentv_event) _opentv_events;
-
/* Event list comparator */
static int _ev_cmp ( void *_a, void *_b )
{
@@ -399,7 +288,8 @@ static int _opentv_parse_event_record
/* Parse a specific event */
static int _opentv_parse_event
- ( opentv_module_t *prov, uint8_t *buf, int len, int cid, time_t mjd,
+ ( opentv_module_t *prov, opentv_status_t *sta,
+ uint8_t *buf, int len, int cid, time_t mjd,
opentv_event_t *ev, int type )
{
int slen = ((int)buf[2] & 0xf << 8) | buf[3];
@@ -410,9 +300,9 @@ static int _opentv_parse_event
ev->eid = ((uint16_t)buf[0] << 8) | buf[1];
/* Get existing summary */
- e = RB_FIND(&_opentv_events, ev, ev_link, _ev_cmp);
+ e = RB_FIND(&sta->events, ev, ev_link, _ev_cmp);
if (e) {
- RB_REMOVE(&_opentv_events, e, ev_link);
+ RB_REMOVE(&sta->events, e, ev_link);
memcpy(ev, e, sizeof(opentv_event_t));
free(e);
}
@@ -427,7 +317,8 @@ static int _opentv_parse_event
/* Parse an event section */
static int _opentv_parse_event_section
- ( opentv_module_t *mod, uint8_t *buf, int len, int type )
+ ( opentv_module_t *mod, opentv_status_t *sta,
+ uint8_t *buf, int len, int type )
{
int i, cid, save = 0;
time_t mjd;
@@ -452,7 +343,7 @@ static int _opentv_parse_event_section
i = 7;
while (i < len) {
memset(&ev, 0, sizeof(opentv_event_t));
- i += _opentv_parse_event(mod, buf+i, len-i, cid, mjd, &ev, type);
+ i += _opentv_parse_event(mod, sta, buf+i, len-i, cid, mjd, &ev, type);
/* Find broadcast */
if (ev.type & OPENTV_TITLE) {
@@ -465,7 +356,7 @@ static int _opentv_parse_event_section
if (!ebc) {
opentv_event_t *skel = malloc(sizeof(opentv_event_t));
memcpy(skel, &ev, sizeof(opentv_event_t));
- assert(!RB_INSERT_SORTED(&_opentv_events, skel, ev_link, _ev_cmp));
+ assert(!RB_INSERT_SORTED(&sta->events, skel, ev_link, _ev_cmp));
continue; // don't want to free() anything
}
}
@@ -561,7 +452,7 @@ static int _opentv_parse_ts_desc
}
static int _opentv_bat_section
- ( opentv_module_t *mod, uint8_t *buf, int len )
+ ( opentv_module_t *mod, opentv_status_t *sta, uint8_t *buf, int len )
{
int i, r;
int bdlen, tllen, tdlen;
@@ -579,10 +470,10 @@ static int _opentv_bat_section
// Note: this is NOT the most robust of approaches, but it works
// most of the time
i = 0x80000000 | (bid << 8) | sec;
- if (!mod->begbat) {
- mod->begbat = i;
- } else if (mod->begbat == i) {
- mod->endbat = 1;
+ if (!sta->begbat) {
+ sta->begbat = i;
+ } else if (sta->begbat == i) {
+ sta->endbat = 1;
return 0;
}
@@ -621,36 +512,27 @@ static int _opentv_bat_section
* Table Callbacks
* ***********************************************************************/
-static opentv_module_t *_opentv_table_callback
+static epggrab_ota_mux_t *_opentv_table_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
{
th_dvb_table_t *tdt = (th_dvb_table_t*)p;
- opentv_module_t *mod = (opentv_module_t*)tdt->tdt_opaque;
- epggrab_ota_mux_t *ota;
- opentv_status_t *sta;
+ epggrab_ota_mux_t *ota = tdt->tdt_opaque;
+ opentv_status_t *sta = ota->status;
+ opentv_pid_status_t *pid;
- /* Ignore BAT not complete */
- if (!mod->endbat) return NULL;
-
/* Ignore (not enough data) */
if (len < 20) return NULL;
- /* Register */
- ota = epggrab_ota_register((epggrab_module_t*)mod, tdmi,
- OPENTV_SCAN_MAX, OPENTV_SCAN_PER);
- if (!ota) return NULL;
-
/* Finished / Blocked */
if (epggrab_ota_is_complete(ota)) return NULL;
- if (epggrab_ota_is_blocked(ota)) return NULL;
/* Begin (reset state) */
if (epggrab_ota_begin(ota)) {
opentv_event_t *ev;
/* Remove outstanding event data */
- while ((ev = RB_FIRST(&_opentv_events))) {
- RB_REMOVE(&_opentv_events, ev, ev_link);
+ while ((ev = RB_FIRST(&sta->events))) {
+ RB_REMOVE(&sta->events, ev, ev_link);
if (ev->title) free(ev->title);
if (ev->desc) free(ev->desc);
if (ev->summary) free(ev->summary);
@@ -658,34 +540,34 @@ static opentv_module_t *_opentv_table_callback
}
/* Reset status */
- LIST_FOREACH(sta, &mod->status, link)
- sta->status = OPENTV_STA_INIT;
+ LIST_FOREACH(pid, &sta->pids, link)
+ pid->state = OPENTV_PID_INIT;
}
/* Insert/Find */
- sta = _opentv_module_get_status(mod, tdt->tdt_pid);
+ pid = _opentv_get_pid_status(sta, tdt->tdt_pid);
/* Begin PID */
- if (sta->status == OPENTV_STA_INIT) {
- sta->status = OPENTV_STA_STARTED;
- memcpy(sta->start, buf, 20);
- return mod;
+ if (pid->state == OPENTV_PID_INIT) {
+ pid->state = OPENTV_PID_STARTED;
+ memcpy(pid->start, buf, 20);
+ return ota;
/* PID Already complete */
- } else if (sta->status == OPENTV_STA_COMPLETE) {
+ } else if (pid->state == OPENTV_PID_COMPLETE) {
return NULL;
/* End PID */
- } else if (!memcmp(sta->start, buf, 20)) {
- sta->status = OPENTV_STA_COMPLETE;
+ } else if (!memcmp(pid->start, buf, 20)) {
+ pid->state = OPENTV_PID_COMPLETE;
/* Check rest */
- LIST_FOREACH(sta, &mod->status, link)
- if (sta->status != OPENTV_STA_COMPLETE) return mod;
+ LIST_FOREACH(pid, &sta->pids, link)
+ if (pid->state != OPENTV_PID_COMPLETE) return ota;
/* PID in progress */
} else {
- return mod;
+ return ota;
}
/* Mark complete */
@@ -697,91 +579,115 @@ static opentv_module_t *_opentv_table_callback
static int _opentv_title_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
{
- opentv_module_t *mod = _opentv_table_callback(tdmi, buf, len, tid, p);
- if (mod)
- return _opentv_parse_event_section(mod, buf, len, OPENTV_TITLE);
+ epggrab_ota_mux_t *ota = _opentv_table_callback(tdmi, buf, len, tid, p);
+ if (ota)
+ return _opentv_parse_event_section((opentv_module_t*)ota->grab,
+ (opentv_status_t*)ota->status,
+ buf, len, OPENTV_TITLE);
return 0;
}
static int _opentv_summary_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
{
- opentv_module_t *mod = _opentv_table_callback(tdmi, buf, len, tid, p);
- if (mod)
- return _opentv_parse_event_section(mod, buf, len, OPENTV_SUMMARY);
+ epggrab_ota_mux_t *ota = _opentv_table_callback(tdmi, buf, len, tid, p);
+ if (ota)
+ return _opentv_parse_event_section((opentv_module_t*)ota->grab,
+ (opentv_status_t*)ota->status,
+ buf, len, OPENTV_SUMMARY);
return 0;
}
static int _opentv_channel_callback
( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
{
- opentv_module_t *mod = (opentv_module_t*)p;
- if (!mod->endbat)
- return _opentv_bat_section(mod, buf, len);
+ epggrab_ota_mux_t *ota = (epggrab_ota_mux_t*)p;
+ opentv_status_t *sta = ota->status;
+ if (!sta->endbat)
+ return _opentv_bat_section((opentv_module_t*)ota->grab, sta, buf, len);
return 0;
}
/* ************************************************************************
- * Module Setup
+ * Module callbacks
* ***********************************************************************/
-static void _opentv_tune ( epggrab_module_t *m, th_dvb_mux_instance_t *tdmi )
+static void _opentv_ota_destroy ( epggrab_ota_mux_t *ota )
+{
+ // TODO
+}
+
+static void _opentv_start
+ ( epggrab_module_ota_t *m, th_dvb_mux_instance_t *tdmi )
{
int *t;
struct dmx_sct_filter_params *fp;
+ epggrab_ota_mux_t *ota;
opentv_module_t *mod = (opentv_module_t*)m;
+ opentv_status_t *sta;
+
+ /* Ignore */
+ if (!m->enabled) return;
+ if (mod->tsid != tdmi->tdmi_transport_stream_id) return;
+
+ /* Create link */
+ if (!(ota = epggrab_ota_create(m, tdmi))) return;
+ if (!ota->status) {
+ ota->status = calloc(1, sizeof(opentv_status_t));
+ ota->destroy = _opentv_ota_destroy;
+ }
+ sta = ota->status;
+ sta->begbat = sta->endbat = 0;
+
+ /* Register interest (we're always interested in this mux) */
+ epggrab_ota_register(ota, OPENTV_SCAN_MAX, OPENTV_SCAN_PER);
/* Install tables */
- if (m->enabled && (mod->tsid == tdmi->tdmi_transport_stream_id)) {
- tvhlog(LOG_INFO, "opentv", "install provider %s tables", mod->id);
+ tvhlog(LOG_INFO, "opentv", "install provider %s tables", mod->id);
- /* Channels */
- t = mod->channel;
- while (*t) {
- fp = dvb_fparams_alloc();
- fp->filter.filter[0] = 0x4a;
- fp->filter.mask[0] = 0xff;
- // TODO: what about 0x46 (service description)
- tdt_add(tdmi, fp, _opentv_channel_callback, mod,
- m->id, TDT_CRC, *t++, NULL);
- }
+ /* Channels */
+ t = mod->channel;
+ while (*t) {
+ fp = dvb_fparams_alloc();
+ fp->filter.filter[0] = 0x4a;
+ fp->filter.mask[0] = 0xff;
+ // TODO: what about 0x46 (service description)
+ tdt_add(tdmi, fp, _opentv_channel_callback, mod,
+ m->id, TDT_CRC, *t++, NULL);
+ }
- /* Titles */
- t = mod->title;
- while (*t) {
- fp = dvb_fparams_alloc();
- fp->filter.filter[0] = 0xa0;
- fp->filter.mask[0] = 0xfc;
- tdt_add(tdmi, fp, _opentv_title_callback, mod,
- m->id, TDT_CRC | TDT_TDT, *t++, NULL);
- }
+ /* Titles */
+ t = mod->title;
+ while (*t) {
+ fp = dvb_fparams_alloc();
+ fp->filter.filter[0] = 0xa0;
+ fp->filter.mask[0] = 0xfc;
+ tdt_add(tdmi, fp, _opentv_title_callback, mod,
+ m->id, TDT_CRC | TDT_TDT, *t++, NULL);
+ }
- /* Summaries */
- t = mod->summary;
- while (*t) {
- fp = dvb_fparams_alloc();
- fp->filter.filter[0] = 0xa8;
- fp->filter.mask[0] = 0xfc;
- tdt_add(tdmi, fp, _opentv_summary_callback, mod,
- m->id, TDT_CRC | TDT_TDT, *t++, NULL);
- }
-
- /* Must rebuild the BAT */
- mod->begbat = mod->endbat = 0;
+ /* Summaries */
+ t = mod->summary;
+ while (*t) {
+ fp = dvb_fparams_alloc();
+ fp->filter.filter[0] = 0xa8;
+ fp->filter.mask[0] = 0xfc;
+ tdt_add(tdmi, fp, _opentv_summary_callback, mod,
+ m->id, TDT_CRC | TDT_TDT, *t++, NULL);
}
}
-static int _opentv_enable ( epggrab_module_t *m, uint8_t e )
+static int _opentv_enable ( void *m, uint8_t e )
{
- th_dvb_adapter_t *tda;
- th_dvb_mux_instance_t *tdmi;
+ //th_dvb_adapter_t *tda;
+ //th_dvb_mux_instance_t *tdmi;
opentv_module_t *mod = (opentv_module_t*)m;
- if (m->enabled == e) return 0;
+ if (mod->enabled == e) return 0;
+ mod->enabled = e;
- m->enabled = e;
-
- /* Find muxes and enable/disable */
+ /* TODO
+ * Find muxes and enable/disable *
TAILQ_FOREACH(tda, &dvb_adapters, tda_global_link) {
LIST_FOREACH(tdmi, &tda->tda_muxes, tdmi_adapter_link) {
if (tdmi->tdmi_transport_stream_id != mod->tsid) continue;
@@ -792,11 +698,138 @@ static int _opentv_enable ( epggrab_module_t *m, uint8_t e )
}
}
}
+*/
return 1;
}
-void opentv_init ( epggrab_module_list_t *list )
+/* ************************************************************************
+ * Configuration
+ * ***********************************************************************/
+
+static int* _pid_list_to_array ( htsmsg_t *m )
+{
+ int i = 1;
+ int *ret;
+ htsmsg_field_t *f;
+ HTSMSG_FOREACH(f, m)
+ if (f->hmf_s64) i++;
+ ret = calloc(i, sizeof(int));
+ i = 0;
+ HTSMSG_FOREACH(f, m)
+ if (f->hmf_s64) {
+ ret[i] = (int)f->hmf_s64;
+ i++;
+ }
+ return ret;
+}
+
+static int _opentv_dict_load_one ( const char *id, htsmsg_t *m )
+{
+ opentv_dict_t *dict = calloc(1, sizeof(opentv_dict_t));
+ dict->id = (char*)id;
+ if (RB_INSERT_SORTED(&_opentv_dicts, dict, h_link, _dict_cmp)) {
+ tvhlog(LOG_DEBUG, "opentv", "ignore duplicate dictionary %s", id);
+ free(dict);
+ return 0;
+ } else {
+ dict->codes = huffman_tree_build(m);
+ if (!dict->codes) {
+ RB_REMOVE(&_opentv_dicts, dict, h_link);
+ free(dict);
+ return -1;
+ } else {
+ dict->id = strdup(id);
+ return 1;
+ }
+ }
+}
+
+static void _opentv_dict_load ( htsmsg_t *m )
+{
+ int r;
+ htsmsg_t *e;
+ htsmsg_field_t *f;
+ HTSMSG_FOREACH(f, m) {
+ if ((e = htsmsg_get_list(m, f->hmf_name))) {
+ if ((r = _opentv_dict_load_one(f->hmf_name, e))) {
+ if (r > 0)
+ tvhlog(LOG_INFO, "opentv", "dictionary %s loaded", f->hmf_name);
+ else
+ tvhlog(LOG_WARNING, "opentv", "dictionary %s failed", f->hmf_name);
+ }
+ }
+ }
+ htsmsg_destroy(m);
+}
+
+static int _opentv_prov_load_one ( const char *id, htsmsg_t *m )
+{
+ char ibuf[100], nbuf[1000];
+ htsmsg_t *cl, *tl, *sl;
+ uint32_t tsid, sid, nid;
+ const char *str, *name;
+ opentv_dict_t *dict;
+ opentv_module_t *mod;
+
+ /* Check config */
+ if (!(name = htsmsg_get_str(m, "name"))) return -1;
+ if (!(str = htsmsg_get_str(m, "dict"))) return -1;
+ if (!(dict = _opentv_dict_find(str))) return -1;
+ if (!(cl = htsmsg_get_list(m, "channel"))) return -1;
+ if (!(tl = htsmsg_get_list(m, "title"))) return -1;
+ if (!(sl = htsmsg_get_list(m, "summary"))) return -1;
+ if (htsmsg_get_u32(m, "nid", &nid)) return -1;
+ if (htsmsg_get_u32(m, "tsid", &tsid)) return -1;
+ if (htsmsg_get_u32(m, "sid", &sid)) return -1;
+
+ /* Exists (we expect some duplicates due to config layout) */
+ sprintf(ibuf, "opentv-%s", id);
+ if (epggrab_module_find_by_id(ibuf)) return 0;
+
+ /* Create */
+ sprintf(nbuf, "OpenTV: %s", name);
+ mod = (opentv_module_t*)
+ epggrab_module_ota_create(calloc(1, sizeof(opentv_module_t)),
+ ibuf, nbuf,
+ _opentv_start, _opentv_enable,
+ &_opentv_channels);
+
+ /* Add provider details */
+ mod->dict = dict;
+ mod->nid = nid;
+ mod->tsid = tsid;
+ mod->sid = sid;
+ mod->channel = _pid_list_to_array(cl);
+ mod->title = _pid_list_to_array(tl);
+ mod->summary = _pid_list_to_array(sl);
+
+ return 1;
+}
+
+static void _opentv_prov_load ( htsmsg_t *m )
+{
+ int r;
+ htsmsg_t *e;
+ htsmsg_field_t *f;
+ HTSMSG_FOREACH(f, m) {
+ if ((e = htsmsg_get_map_by_field(f))) {
+ if ((r = _opentv_prov_load_one(f->hmf_name, e))) {
+ if (r > 0)
+ tvhlog(LOG_INFO, "opentv", "provider %s loaded", f->hmf_name);
+ else
+ tvhlog(LOG_WARNING, "opentv", "provider %s failed", f->hmf_name);
+ }
+ }
+ }
+ htsmsg_destroy(m);
+}
+
+/* ************************************************************************
+ * Module Setup
+ * ***********************************************************************/
+
+void opentv_init ( void )
{
htsmsg_t *m;
const char *dr = tvheadend_dataroot();
@@ -810,9 +843,9 @@ void opentv_init ( epggrab_module_list_t *list )
/* Load providers */
if ((m = hts_settings_load("epggrab/opentv/prov")))
- _opentv_prov_load(m, list);
+ _opentv_prov_load(m);
if ((m = hts_settings_load("%sdata/epggrab/opentv/prov", dr)))
- _opentv_prov_load(m, list);
+ _opentv_prov_load(m);
tvhlog(LOG_INFO, "opentv", "providers loaded");
}
diff --git a/src/epggrab/pyepg.c b/src/epggrab/module/pyepg.c
similarity index 87%
rename from src/epggrab/pyepg.c
rename to src/epggrab/module/pyepg.c
index 8207aa4b..167493be 100644
--- a/src/epggrab/pyepg.c
+++ b/src/epggrab/module/pyepg.c
@@ -24,18 +24,17 @@
#include "htsmsg_xml.h"
#include "tvheadend.h"
#include "spawn.h"
-#include "epg.h"
-#include "epggrab/pyepg.h"
-#include "epggrab/xmltv.h"
#include "channels.h"
+#include "epg.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
static epggrab_channel_tree_t _pyepg_channels;
-static epggrab_module_t *_pyepg_module;
static epggrab_channel_t *_pyepg_channel_find
( const char *id, int create, int *save )
{
- return epggrab_module_channel_find(_pyepg_module, id, create, save);
+ return epggrab_channel_find(&_pyepg_channels, id, create, save);
}
/* **************************************************************************
@@ -69,7 +68,7 @@ static int _pyepg_parse_channel ( htsmsg_t *data, epggrab_stats_t *stats )
const char *str;
uint32_t u32;
const char *sname[11];
- uint16_t sid[10];
+ uint16_t sid[11];
int sid_idx = 0, sname_idx = 0;
if ( data == NULL ) return 0;
@@ -108,7 +107,10 @@ static int _pyepg_parse_channel ( htsmsg_t *data, epggrab_stats_t *stats )
}
}
}
- if (sid_idx) save |= epggrab_channel_set_sid(ch, sid, sid_idx);
+ if (sid_idx) {
+ sid[sid_idx] = 0;
+ save |= epggrab_channel_set_sid(ch, sid);
+ }
if (sname_idx) {
sname[sname_idx] = NULL;
save |= epggrab_channel_set_sname(ch, sname);
@@ -412,14 +414,8 @@ static int _pyepg_parse_epg ( htsmsg_t *data, epggrab_stats_t *stats )
return save;
}
-
-/* ************************************************************************
- * Module Setup
- * ***********************************************************************/
-
-
static int _pyepg_parse
- ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats )
+ ( void *mod, htsmsg_t *data, epggrab_stats_t *stats )
{
htsmsg_t *tags, *epg;
@@ -432,40 +428,24 @@ static int _pyepg_parse
return 0;
}
-void pyepg_init ( epggrab_module_list_t *list )
-{
- epggrab_module_t *mod;
+/* ************************************************************************
+ * Module Setup
+ * ***********************************************************************/
- /* Standard module */
- mod = calloc(1, sizeof(epggrab_module_t));
- mod->id = strdup("pyepg");
- mod->path = strdup("/usr/bin/pyepg");
- mod->name = strdup("PyEPG");
- mod->grab = epggrab_module_grab;
- mod->trans = epggrab_module_trans_xml;
- mod->parse = _pyepg_parse;
- mod->channels = &_pyepg_channels;
- mod->ch_add = epggrab_module_channel_add;
- mod->ch_rem = epggrab_module_channel_rem;
- mod->ch_mod = epggrab_module_channel_mod;
- *((uint8_t*)&mod->flags) = EPGGRAB_MODULE_INTERNAL;
- LIST_INSERT_HEAD(list, mod, link);
- _pyepg_module = mod;
+void pyepg_init ( void )
+{
+ /* Internal module */
+ epggrab_module_int_create(NULL, "pyepg", "PyEPG", "/usr/bin/pyepg",
+ NULL, _pyepg_parse, NULL,
+ &_pyepg_channels);
/* External module */
- mod = calloc(1, sizeof(epggrab_module_t));
- mod->id = strdup("pyepg_ext");
- mod->path = epggrab_module_socket_path("pyepg");
- mod->name = strdup("PyEPG");
- mod->channels = &_pyepg_channels;
- mod->enable = epggrab_module_enable_socket;
- mod->trans = epggrab_module_trans_xml;
- mod->parse = _pyepg_parse;
- *((uint8_t*)&mod->flags) = EPGGRAB_MODULE_EXTERNAL;
- LIST_INSERT_HEAD(list, mod, link);
+ epggrab_module_ext_create(NULL, "pyepg.ext", "PyEPG", "pyepg",
+ _pyepg_parse, NULL,
+ &_pyepg_channels);
}
void pyepg_load ( void )
{
- epggrab_module_channels_load(_pyepg_module);
+ // TODO epggrab_module_channels_load(_pyepg_module);
}
diff --git a/src/epggrab/xmltv.c b/src/epggrab/module/xmltv.c
similarity index 87%
rename from src/epggrab/xmltv.c
rename to src/epggrab/module/xmltv.c
index 442a4993..7b4bfa7e 100644
--- a/src/epggrab/xmltv.c
+++ b/src/epggrab/module/xmltv.c
@@ -31,19 +31,20 @@
#include "tvheadend.h"
#include "channels.h"
-#include "epg.h"
-#include "xmltv.h"
#include "spawn.h"
+#include "epg.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
+
#define XMLTV_FIND_GRABBERS "/usr/bin/tv_find_grabbers"
static epggrab_channel_tree_t _xmltv_channels;
-static epggrab_module_t *_xmltv_module;
static epggrab_channel_t *_xmltv_channel_find
( const char *id, int create, int *save )
{
- return epggrab_module_channel_find(_xmltv_module, id, create, save);
+ return NULL;//return epggrab_module_channel_find(_xmltv_module, id, create, save);
}
@@ -442,12 +443,8 @@ _xmltv_parse_tv(htsmsg_t *body, epggrab_stats_t *stats)
return save;
}
-/* ************************************************************************
- * Module Setup
- * ***********************************************************************/
-
static int _xmltv_parse
- ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats )
+ ( void *mod, htsmsg_t *data, epggrab_stats_t *stats )
{
htsmsg_t *tags, *tv;
@@ -460,17 +457,20 @@ static int _xmltv_parse
return _xmltv_parse_tv(tv, stats);
}
-static void _xmltv_load_grabbers ( epggrab_module_list_t *list )
+/* ************************************************************************
+ * Module Setup
+ * ***********************************************************************/
+
+static void _xmltv_load_grabbers ( void )
{
size_t i, outlen, p, n;
char *outbuf;
- char errbuf[100];
- epggrab_module_t *mod;
+ char name[1000];
/* Load data */
outlen = spawn_and_store_stdout(XMLTV_FIND_GRABBERS, NULL, &outbuf);
if ( outlen < 1 ) {
- tvhlog(LOG_ERR, "xmltv", "%s failed [%s]", XMLTV_FIND_GRABBERS, errbuf);
+ tvhlog(LOG_ERR, "xmltv", "%s failed", XMLTV_FIND_GRABBERS);
return;
}
@@ -479,16 +479,10 @@ static void _xmltv_load_grabbers ( epggrab_module_list_t *list )
while ( i < outlen ) {
if ( outbuf[i] == '\n' || outbuf[i] == '\0' ) {
outbuf[i] = '\0';
- mod = calloc(1, sizeof(epggrab_module_t));
- mod->id = mod->path = strdup(&outbuf[p]);
- mod->name = malloc(200);
- mod->channels = &_xmltv_channels;
- sprintf((char*)mod->name, "XMLTV: %s", &outbuf[n]);
- *((uint8_t*)&mod->flags) = EPGGRAB_MODULE_INTERNAL;
- mod->grab = epggrab_module_grab;
- mod->trans = epggrab_module_trans_xml;
- mod->parse = _xmltv_parse;
- LIST_INSERT_HEAD(list, mod, link);
+ sprintf(name, "XMLTV: %s", &outbuf[n]);
+ epggrab_module_int_create(NULL, &outbuf[p], name, &outbuf[p],
+ NULL, _xmltv_parse, NULL,
+ &_xmltv_channels);
p = n = i + 1;
} else if ( outbuf[i] == '|' ) {
outbuf[i] = '\0';
@@ -499,31 +493,18 @@ static void _xmltv_load_grabbers ( epggrab_module_list_t *list )
free(outbuf);
}
-void xmltv_init ( epggrab_module_list_t *list )
+void xmltv_init ( void )
{
- epggrab_module_t *mod;
-
/* External module */
- mod = calloc(1, sizeof(epggrab_module_t));
- mod->id = strdup("xmltv");
- mod->name = strdup("XMLTV");
- mod->path = epggrab_module_socket_path("xmltv");
- mod->enable = epggrab_module_enable_socket;
- mod->trans = epggrab_module_trans_xml;
- mod->parse = _xmltv_parse;
- mod->channels = &_xmltv_channels;
- mod->ch_add = epggrab_module_channel_add;
- mod->ch_rem = epggrab_module_channel_rem;
- mod->ch_mod = epggrab_module_channel_mod;
- *((uint8_t*)&mod->flags) = EPGGRAB_MODULE_EXTERNAL;
- LIST_INSERT_HEAD(list, mod, link);
- _xmltv_module = mod;
+ epggrab_module_ext_create(NULL, "xmltv", "XMLTV", "xmltv",
+ _xmltv_parse, NULL,
+ &_xmltv_channels);
/* Standard modules */
- _xmltv_load_grabbers(list);
+ _xmltv_load_grabbers();
}
void xmltv_load ( void )
{
- epggrab_module_channels_load(_xmltv_module);
+ //epggrab_module_channels_load(_xmltv_module);
}
diff --git a/src/epggrab/opentv.h b/src/epggrab/opentv.h
deleted file mode 100644
index e46525d9..00000000
--- a/src/epggrab/opentv.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Electronic Program Guide - opentv
- * Copyright (C) 2012 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 .
- */
-
-#ifndef __TVH_EPGGRAB_OPENTV_H__
-#define __TVH_EPGGRAB_OPENTV_H__
-
-#include "dvb/dvb.h"
-#include "epggrab.h"
-
-void opentv_tune ( th_dvb_mux_instance_t *tdmi );
-void opentv_init ( epggrab_module_list_t *list );
-void opentv_load ( void );
-
-#endif /* __TVH_EPGGRAB_OPENTV_H__ */
diff --git a/src/epggrab/ota.c b/src/epggrab/ota.c
deleted file mode 100644
index 2dc132d5..00000000
--- a/src/epggrab/ota.c
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Electronic Program Guide - EPG grabber OTA functions
- * Copyright (C) 2012 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 .
- */
-
-#include "tvheadend.h"
-#include "queue.h"
-#include "epg.h"
-#include "dvb/dvb.h"
-#include "epggrab.h"
-#include "epggrab/ota.h"
-
-LIST_HEAD(,epggrab_ota_mux) ota_muxes;
-
-epggrab_ota_mux_t *epggrab_ota_register
- ( epggrab_module_t *mod, th_dvb_mux_instance_t *tdmi,
- int timeout, int interval )
-{
- epggrab_ota_mux_t *ota;
-
- /* Check for existing */
- LIST_FOREACH(ota, &ota_muxes, glob_link) {
- if (ota->grab == mod && ota->tdmi == tdmi) {
- ota->timeout = MAX(ota->timeout, timeout);
- ota->interval = MIN(ota->interval, interval);
- return ota;
- }
- }
-
- /* Install new */
- ota = calloc(1, sizeof(epggrab_ota_mux_t));
- ota->grab = mod;
- ota->tdmi = tdmi;
- ota->timeout = timeout;
- ota->interval = interval;
- LIST_INSERT_HEAD(&ota_muxes, ota, glob_link);
- LIST_INSERT_HEAD(&tdmi->tdmi_epg_grabbers, ota, tdmi_link);
- LIST_INSERT_HEAD(&mod->muxes, ota, grab_link);
-
- /* Re-assign to correct queue */
- if (tdmi->tdmi_scan_queue)
- TAILQ_REMOVE(tdmi->tdmi_scan_queue, tdmi, tdmi_scan_link);
- dvb_mux_add_to_scan_queue(tdmi);
-
- return ota;
-}
-
-/*
- * Unregister
- */
-void epggrab_ota_unregister ( epggrab_ota_mux_t *ota )
-{
- LIST_REMOVE(ota, glob_link);
- LIST_REMOVE(ota, tdmi_link);
- LIST_REMOVE(ota, grab_link);
- free(ota);
-}
-
-void epggrab_ota_unregister_one
- ( epggrab_module_t *mod, th_dvb_mux_instance_t *tdmi )
-{
- epggrab_ota_mux_t *ota;
- LIST_FOREACH(ota, &ota_muxes, glob_link) {
- if (ota->grab == mod && (!tdmi || ota->tdmi == tdmi)) {
- epggrab_ota_unregister(ota);
- if (tdmi) break;
- }
- }
-}
-
-void epggrab_ota_unregister_all
- ( epggrab_module_t *mod )
-{
- epggrab_ota_unregister_one(mod, NULL);
-}
-
-/*
- * Status
- */
-int epggrab_ota_begin ( epggrab_ota_mux_t *ota )
-{
- if (ota->status == EPGGRAB_OTA_IDLE) {
- ota->status = EPGGRAB_OTA_STARTED;
- time(&ota->started);
- return 1;
- }
- return 0;
-}
-
-void epggrab_ota_complete ( epggrab_ota_mux_t *ota )
-{
- if (ota->status != EPGGRAB_OTA_COMPLETED)
- time(&ota->completed);
- ota->status = EPGGRAB_OTA_COMPLETED;
-}
-
-void epggrab_ota_cancel ( epggrab_ota_mux_t *ota )
-{
- ota->status = EPGGRAB_OTA_IDLE;
-}
-
-void epggrab_ota_timeout ( epggrab_ota_mux_t *ota )
-{
- epggrab_ota_complete(ota);
-}
-
-int epggrab_ota_is_complete ( epggrab_ota_mux_t *ota )
-{
- return ota->status == EPGGRAB_OTA_COMPLETED;
-}
-
-int epggrab_ota_is_blocked ( epggrab_ota_mux_t *ota )
-{
- time_t t;
- time(&t);
- return t < (ota->completed + ota->interval);
-}
diff --git a/src/epggrab/ota.h b/src/epggrab/ota.h
deleted file mode 100644
index f1220906..00000000
--- a/src/epggrab/ota.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Electronic Program Guide - EPG grabber OTA functions
- * Copyright (C) 2012 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 .
- */
-
-#ifndef __TVH_EPGGRAB_OTA_H__
-#define __TVH_EPGGRAB_OTA_H__
-
-#include "queue.h"
-#include
-
-/*
- * Mux to OTA Grabber link
- */
-typedef struct epggrab_ota_mux
-{
- LIST_ENTRY(epggrab_ota_mux) glob_link; ///< Global list of all instances
- LIST_ENTRY(epggrab_ota_mux) grab_link; ///< Grabber's list link
- LIST_ENTRY(epggrab_ota_mux) tdmi_link; ///< Mux list link
- struct epggrab_module *grab; ///< Grabber module
- struct th_dvb_mux_instance *tdmi; ///< Mux instance
-
- int timeout; ///< Time out if this long
- int interval; ///< Re-grab this often
-
- enum {
- EPGGRAB_OTA_IDLE,
- EPGGRAB_OTA_STARTED,
- EPGGRAB_OTA_COMPLETED
- } status; ///< Status of the scan
- time_t started; ///< Time of last start
- time_t completed; ///< Time of last completion
-
-} epggrab_ota_mux_t;
-
-/*
- * Register interest (will return existing if already registered)
- */
-epggrab_ota_mux_t *epggrab_ota_register
- ( struct epggrab_module *mod, struct th_dvb_mux_instance *tdmi,
- int timeout, int interval );
-
-/*
- * Unregister
- */
-void epggrab_ota_unregister
- ( epggrab_ota_mux_t *ota );
-void epggrab_ota_unregister_one
- ( struct epggrab_module *mod, struct th_dvb_mux_instance *tdmi );
-void epggrab_ota_unregister_all
- ( struct epggrab_module *mod );
-
-/*
- * Status
- */
-int epggrab_ota_begin ( epggrab_ota_mux_t *ota );
-void epggrab_ota_complete ( epggrab_ota_mux_t *ota );
-void epggrab_ota_cancel ( epggrab_ota_mux_t *ota );
-void epggrab_ota_timeout ( epggrab_ota_mux_t *ota );
-int epggrab_ota_is_complete ( epggrab_ota_mux_t *ota );
-int epggrab_ota_is_blocked ( epggrab_ota_mux_t *ota );
-
-#endif /* __TVH_EPGGRAB_OTA_H__ */
diff --git a/src/epggrab/otamux.c b/src/epggrab/otamux.c
new file mode 100644
index 00000000..54487424
--- /dev/null
+++ b/src/epggrab/otamux.c
@@ -0,0 +1,256 @@
+/*
+ * Electronic Program Guide - EPG grabber OTA functions
+ * Copyright (C) 2012 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 .
+ */
+
+/*
+ * TODO: this current implementation is a bit naff, possibly not as
+ * efficient as it could be (due to use of the a single list). But generally
+ * the length of the list will be short and it shouldn't significantly
+ * impact the overall performance
+ *
+ * TODO: currently all muxes are treated independently, this might result
+ * in the same mux being scanned on multiple adapters, which is
+ * a bit pointless.
+ *
+ * I think that at least _mux_next() and _ota_complete() need
+ * updating to handle this
+ */
+
+#include "tvheadend.h"
+#include "queue.h"
+#include "epg.h"
+#include "dvb/dvb.h"
+#include "epggrab.h"
+#include "epggrab/private.h"
+
+LIST_HEAD(,epggrab_ota_mux) ota_mux_all;
+TAILQ_HEAD(, epggrab_ota_mux) ota_mux_reg;
+
+/* **************************************************************************
+ * Global functions (called from DVB code)
+ * *************************************************************************/
+
+void epggrab_mux_start ( th_dvb_mux_instance_t *tdmi )
+{
+ epggrab_module_t *m;
+ epggrab_module_ota_t *mod;
+ LIST_FOREACH(m, &epggrab_modules, link) {
+ if (m->type == EPGGRAB_OTA) {
+ mod = (epggrab_module_ota_t*)m;
+ mod->start(mod, tdmi);
+ }
+ }
+}
+
+void epggrab_mux_stop ( th_dvb_mux_instance_t *tdmi, int timeout )
+{
+ epggrab_ota_mux_t *a, *b;
+ a = LIST_FIRST(&ota_mux_all);
+ while (a) {
+ b = LIST_NEXT(a, glob_link);
+ if (a->tdmi == tdmi) {
+ if (timeout)
+ epggrab_ota_timeout(a);
+ else
+ epggrab_ota_cancel(a);
+ }
+ a = b;
+ }
+}
+
+void epggrab_mux_delete ( th_dvb_mux_instance_t *tdmi )
+{
+ epggrab_ota_mux_t *a, *b;
+ a = LIST_FIRST(&ota_mux_all);
+ while (a) {
+ b = LIST_NEXT(a, glob_link);
+ if (a->tdmi == tdmi)
+ epggrab_ota_destroy(a);
+ a = b;
+ }
+}
+
+int epggrab_mux_period ( th_dvb_mux_instance_t *tdmi )
+{
+ int period = 0;
+ epggrab_ota_mux_t *ota;
+ TAILQ_FOREACH(ota, &ota_mux_reg, reg_link) {
+ if (ota->timeout > period)
+ period = ota->timeout;
+ }
+ return period;
+}
+
+th_dvb_mux_instance_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
+{
+ epggrab_ota_mux_t *ota;
+ TAILQ_FOREACH(ota, &ota_mux_reg, reg_link) {
+ if (ota->tdmi->tdmi_adapter == tda) break;
+ }
+ if (!ota) return NULL;
+ return ota->tdmi;
+}
+
+/* **************************************************************************
+ * OTA Mux link functions
+ * *************************************************************************/
+
+/*
+ * Comprison of ota_mux instances based on when they can next run
+ *
+ * Note: ordering isn't garaunteed to be perfect as we use the current time
+ */
+static int _ota_time_cmp ( void *_a, void *_b )
+{
+ time_t now, wa, wb;
+ time(&now);
+ epggrab_ota_mux_t *a = _a;
+ epggrab_ota_mux_t *b = _b;
+ wa = a->completed + a->interval;
+ wb = b->completed + b->interval;
+ if (wa < now && wb < now)
+ return a->started - b->started;
+ else
+ return wa - wb;
+}
+
+/*
+ * Create (temporary) or Find (existing) link
+ */
+epggrab_ota_mux_t *epggrab_ota_create
+ ( epggrab_module_ota_t *mod, th_dvb_mux_instance_t *tdmi )
+{
+ /* Search for existing */
+ epggrab_ota_mux_t *ota;
+ LIST_FOREACH(ota, &ota_mux_all, glob_link) {
+ if (ota->grab == mod && ota->tdmi == tdmi) break;
+ }
+
+ /* Create new */
+ if (!ota) {
+ ota = calloc(1, sizeof(epggrab_ota_mux_t));
+ ota->grab = mod;
+ ota->tdmi = tdmi;
+ LIST_INSERT_HEAD(&ota_mux_all, ota, glob_link);
+
+ } else {
+ time_t now;
+ time(&now);
+ if (ota) ota->state = EPGGRAB_OTA_MUX_IDLE;
+
+ /* Blocked */
+ if (epggrab_ota_is_blocked(ota)) ota = NULL;
+ }
+ return ota;
+}
+
+/*
+ * Destrory link (either because it was temporary OR mux deleted)
+ */
+void epggrab_ota_destroy ( epggrab_ota_mux_t *ota )
+{
+ LIST_REMOVE(ota, glob_link);
+ if (ota->is_reg) TAILQ_REMOVE(&ota_mux_reg, ota, reg_link);
+ if (ota->destroy) ota->destroy(ota);
+ else {
+ if (ota->status) free(ota->status);
+ free(ota);
+ }
+}
+
+/*
+ * Register interest (called when useful data exists on the MUX
+ * thus inserting it into the EPG scanning queue
+ */
+void epggrab_ota_register ( epggrab_ota_mux_t *ota, int timeout, int interval )
+{
+ // TODO: handle changes to the interval/timeout?
+ if (!ota->is_reg) {
+ ota->timeout = timeout;
+ ota->interval = interval;
+ ota->is_reg = 1;
+ TAILQ_INSERT_SORTED(&ota_mux_reg, ota, reg_link, _ota_time_cmp);
+ }
+}
+
+/*
+ * State changes
+ */
+
+static void _epggrab_ota_finished ( epggrab_ota_mux_t *ota )
+{
+ /* Temporary link - delete it */
+ if (!ota->is_reg)
+ epggrab_ota_destroy(ota);
+
+ /* Reinsert into reg queue */
+ else {
+ TAILQ_REMOVE(&ota_mux_reg, ota, reg_link);
+ TAILQ_INSERT_SORTED(&ota_mux_reg, ota, reg_link, _ota_time_cmp);
+ }
+}
+
+int epggrab_ota_begin ( epggrab_ota_mux_t *ota )
+{
+ if (ota->state == EPGGRAB_OTA_MUX_IDLE) {
+ ota->state = EPGGRAB_OTA_MUX_RUNNING;
+ time(&ota->started);
+ return 1;
+ }
+ return 0;
+}
+
+void epggrab_ota_complete ( epggrab_ota_mux_t *ota )
+{
+ if (ota->state != EPGGRAB_OTA_MUX_COMPLETE) {
+ ota->state = EPGGRAB_OTA_MUX_COMPLETE;
+ time(&ota->completed);
+ _epggrab_ota_finished(ota);
+
+ // TODO: need to inform tdmi
+ }
+}
+
+/* Reset */
+void epggrab_ota_cancel ( epggrab_ota_mux_t *ota )
+{
+ ota->state = EPGGRAB_OTA_MUX_IDLE;
+ _epggrab_ota_finished(ota);
+}
+
+/* Same as complete */
+void epggrab_ota_timeout ( epggrab_ota_mux_t *ota )
+{
+ epggrab_ota_complete(ota);
+}
+
+/*
+ * Check status
+ */
+
+int epggrab_ota_is_complete ( epggrab_ota_mux_t *ota )
+{
+ return ota->state == EPGGRAB_OTA_MUX_COMPLETE ||
+ ota->state == EPGGRAB_OTA_MUX_TIMEDOUT;
+}
+
+int epggrab_ota_is_blocked ( epggrab_ota_mux_t *ota )
+{
+ time_t t;
+ time(&t);
+ return t < (ota->completed + ota->interval);
+}
diff --git a/src/epggrab/private.h b/src/epggrab/private.h
new file mode 100644
index 00000000..bbf10f36
--- /dev/null
+++ b/src/epggrab/private.h
@@ -0,0 +1,144 @@
+/*
+ * EPG Grabber - private routines
+ * Copyright (C) 2012 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 .
+ */
+
+#ifndef __EPGGRAB_PRIVATE_H__
+#define __EPGGRAB_PRIVATE_H__
+
+/* **************************************************************************
+ * Generic module routines
+ * *************************************************************************/
+
+epggrab_module_t *epggrab_module_create
+ ( epggrab_module_t *skel,
+ const char *id, const char *name );
+
+char *epggrab_module_grab_spawn ( void *m );
+htsmsg_t *epggrab_module_trans_xml ( void *m, char *data );
+
+void epggrab_module_ch_add ( void *m, struct channel *ch );
+void epggrab_module_ch_rem ( void *m, struct channel *ch );
+void epggrab_module_ch_mod ( void *m, struct channel *ch );
+void epggrab_module_ch_save ( void *m, epggrab_channel_t *ec );
+
+int epggrab_module_enable_socket ( void *m, uint8_t e );
+
+void epggrab_module_parse ( void *m, htsmsg_t *data );
+
+/* **************************************************************************
+ * Channel processing
+ * *************************************************************************/
+
+int epggrab_channel_link ( epggrab_channel_t *ec, struct channel *ch );
+
+epggrab_channel_t *epggrab_channel_find
+ ( epggrab_channel_tree_t *chs, const char *id, int create, int *save );
+
+/* **************************************************************************
+ * Internal module routines
+ * *************************************************************************/
+
+epggrab_module_int_t *epggrab_module_int_create
+ ( epggrab_module_int_t *skel,
+ const char *id, const char *name, const char *path,
+ char* (*grab) (void*m),
+ int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta),
+ htsmsg_t* (*trans) (void *mod, char *data),
+ epggrab_channel_tree_t *channels );
+
+/* **************************************************************************
+ * External module routines
+ * *************************************************************************/
+
+epggrab_module_ext_t *epggrab_module_ext_create
+ ( epggrab_module_ext_t *skel,
+ const char *id, const char *name, const char *sockid,
+ int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta),
+ htsmsg_t* (*trans) (void *mod, char *data),
+ epggrab_channel_tree_t *channels );
+
+/* **************************************************************************
+ * OTA module routines
+ * *************************************************************************/
+
+epggrab_module_ota_t *epggrab_module_ota_create
+ ( epggrab_module_ota_t *skel,
+ const char *id, const char *name,
+ void (*start) (epggrab_module_ota_t*m,
+ struct th_dvb_mux_instance *tdmi),
+ int (*enable) (void *m, uint8_t e ),
+ epggrab_channel_tree_t *channels );
+
+/* **************************************************************************
+ * OTA mux link routines
+ * *************************************************************************/
+
+/*
+ * Create/Find a link (unregistered)
+ *
+ * Note: this will return NULL for an already existing link that is currently
+ * blocked (i.e. has completed within interval period)
+ */
+epggrab_ota_mux_t *epggrab_ota_create
+ ( struct epggrab_module_ota *mod, struct th_dvb_mux_instance *tdmi );
+
+void epggrab_ota_destroy ( epggrab_ota_mux_t *ota );
+
+/*
+ * Register interest
+ */
+void epggrab_ota_register
+ ( epggrab_ota_mux_t *ota, int timeout, int interval );
+
+/*
+ * State change
+ */
+int epggrab_ota_begin ( epggrab_ota_mux_t *ota );
+void epggrab_ota_complete ( epggrab_ota_mux_t *ota );
+void epggrab_ota_cancel ( epggrab_ota_mux_t *ota );
+void epggrab_ota_timeout ( epggrab_ota_mux_t *ota );
+
+/*
+ * Status
+ */
+int epggrab_ota_is_complete ( epggrab_ota_mux_t *ota );
+int epggrab_ota_is_blocked ( epggrab_ota_mux_t *ota );
+
+/* **************************************************************************
+ * Module setup(s)
+ * *************************************************************************/
+
+/* EIT module */
+void eit_init ( void );
+void eit_load ( void );
+
+/* OpenTV module */
+void opentv_init ( void );
+void opentv_load ( void );
+
+/* PyEPG module */
+void pyepg_init ( void );
+void pyepg_load ( void );
+
+/* XMLTV module */
+void xmltv_init ( void );
+void xmltv_load ( void );
+
+/* Note: this is reused by pyepg since they share a common format */
+int xmltv_parse_accessibility ( epg_broadcast_t *ebc, htsmsg_t *m );
+
+#endif /* __EPGGRAB_PRIVATE_H__ */
diff --git a/src/epggrab/pyepg.h b/src/epggrab/pyepg.h
deleted file mode 100644
index 9686c784..00000000
--- a/src/epggrab/pyepg.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Electronic Program Guide - pyepg grabber
- * Copyright (C) 2012 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 .
- */
-
-#ifndef EPGGRAB_PYEPG_H
-#define EPGGRAB_PYEPG_H
-
-#include "epggrab.h"
-
-void pyepg_init ( epggrab_module_list_t *list );
-void pyepg_load ( void );
-
-#endif
diff --git a/src/epggrab/xmltv.h b/src/epggrab/xmltv.h
deleted file mode 100644
index 104842a7..00000000
--- a/src/epggrab/xmltv.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Electronic Program Guide - xmltv grabber
- * Copyright (C) 2012 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 .
- */
-
-#ifndef EPGGRAB_XMLTV_H
-#define EPGGRAB_XMLTV_H
-
-#include "htsmsg.h"
-#include "epggrab.h"
-
-void xmltv_init ( epggrab_module_list_t *list );
-void xmltv_load ( void );
-
-// reused by pyepg
-int xmltv_parse_accessibility ( epg_broadcast_t *ebc, htsmsg_t *m );
-
-#endif