From 8681d718577a6ce1fb816a70c478a37e4b71ea67 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andreas=20=C3=96man?= <andreas@lonelycoder.com>
Date: Wed, 5 Dec 2012 12:03:58 +0100
Subject: [PATCH] Move some table stuff over to dvb_mux_t

---
 src/dvb/dvb.h               |  35 +++----
 src/dvb/dvb_adapter.c       |   2 +-
 src/dvb/dvb_fe.c            |   6 +-
 src/dvb/dvb_multiplex.c     |  33 +++---
 src/dvb/dvb_service.c       |   2 +-
 src/dvb/dvb_tables.c        | 198 ++++++++++++++++++------------------
 src/epggrab.h               |  20 ++--
 src/epggrab/module.c        |   2 +-
 src/epggrab/module/eit.c    |  37 +++----
 src/epggrab/module/opentv.c |  28 ++---
 src/epggrab/otamux.c        |  55 +++++-----
 src/epggrab/private.h       |   8 +-
 12 files changed, 220 insertions(+), 206 deletions(-)

diff --git a/src/dvb/dvb.h b/src/dvb/dvb.h
index cf5de01a..806360e4 100644
--- a/src/dvb/dvb.h
+++ b/src/dvb/dvb.h
@@ -93,11 +93,11 @@ typedef struct dvb_network {
   struct th_dvb_mux_instance_queue dn_initial_scan_queue;
   int dn_initial_num_mux;
 
-  struct th_dvb_mux_instance *dn_mux_epg;
+  struct dvb_mux *dn_mux_epg;
 
   int dn_fe_type;  // Frontend types for this network (FE_QPSK, etc)
 
-  //  struct dvb_mux_list dn_muxes;
+  struct dvb_mux_list dn_muxes;
 
 } dvb_network_t;
 
@@ -108,7 +108,7 @@ typedef struct dvb_network {
  */
 typedef struct dvb_mux {
 
-  //  LIST_ENTRY(dvb_mux) dm_network_link;
+  LIST_ENTRY(dvb_mux) dm_network_link;
   dvb_network_t *dm_dn;
 
   struct service_list dm_services;
@@ -120,6 +120,10 @@ typedef struct dvb_mux {
   char *dm_network_name;     /* Name of network, from NIT table */
   char *dm_default_authority;
 
+  TAILQ_HEAD(, epggrab_ota_mux) dm_epg_grab;
+
+  struct th_dvb_mux_instance *dm_tdmi; // wrong
+
 } dvb_mux_t;
 
 
@@ -172,8 +176,6 @@ typedef struct th_dvb_mux_instance {
   TAILQ_ENTRY(th_dvb_mux_instance) tdmi_scan_link;
   struct th_dvb_mux_instance_queue *tdmi_scan_queue;
 
-  TAILQ_HEAD(, epggrab_ota_mux) tdmi_epg_grab;
-
   struct th_subscription_list tdmi_subscriptions;
 
 } th_dvb_mux_instance_t;
@@ -314,7 +316,7 @@ typedef struct th_dvb_table {
   char *tdt_name;
 
   void *tdt_opaque;
-  int (*tdt_callback)(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
+  int (*tdt_callback)(dvb_mux_t *dm, uint8_t *buf, int len,
 		      uint8_t tableid, void *opaque);
 
 
@@ -426,11 +428,11 @@ th_dvb_mux_instance_t *dvb_mux_create(th_dvb_adapter_t *tda,
 				      const char *logprefix, int enabled,
 				      int initialscan, const char *identifier);
 
-void dvb_mux_set_networkname(th_dvb_mux_instance_t *tdmi, const char *name);
+void dvb_mux_set_networkname(dvb_mux_t *dm, const char *name);
 
-void dvb_mux_set_tsid(th_dvb_mux_instance_t *tdmi, uint16_t tsid);
+void dvb_mux_set_tsid(dvb_mux_t *dm, uint16_t tsid);
 
-void dvb_mux_set_onid(th_dvb_mux_instance_t *tdmi, uint16_t onid);
+void dvb_mux_set_onid(dvb_mux_t *mux, uint16_t onid);
 
 void dvb_mux_set_enable(th_dvb_mux_instance_t *tdmi, int enabled);
 
@@ -501,22 +503,21 @@ void dvb_fe_stop(th_dvb_mux_instance_t *tdmi, int retune);
  */
 void dvb_table_init(th_dvb_adapter_t *tda);
 
-void dvb_table_add_default(th_dvb_mux_instance_t *tdmi);
+void dvb_table_add_default(dvb_mux_t *dm);
 
 void dvb_table_flush_all(th_dvb_mux_instance_t *tdmi);
 
-void dvb_table_add_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid);
+void dvb_table_add_pmt(dvb_mux_t *dm, int pmt_pid);
 
-void dvb_table_rem_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid);
+void dvb_table_rem_pmt(dvb_mux_t *dm, int pmt_pid);
 
-void tdt_add(th_dvb_mux_instance_t *tdmi, int table, int mask,
-	     int (*callback)(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
+void tdt_add(dvb_mux_t *dm, int table, int mask,
+	     int (*callback)(dvb_mux_t *dm, uint8_t *buf, int len,
 			     uint8_t tableid, void *opaque), void *opaque,
 	     const char *name, int flags, int pid);
 
-int dvb_pidx11_callback
-  (th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
-   uint8_t tableid, void *opaque);
+int dvb_pidx11_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
+                        uint8_t tableid, void *opaque);
 
 #define TDT_CRC           0x1
 #define TDT_QUICKREQ      0x2
diff --git a/src/dvb/dvb_adapter.c b/src/dvb/dvb_adapter.c
index 5af203f5..d1d12bb7 100644
--- a/src/dvb/dvb_adapter.c
+++ b/src/dvb/dvb_adapter.c
@@ -748,7 +748,7 @@ dvb_adapter_mux_scanner(void *aux)
     if (period > 20)
       gtimer_arm(&tda->tda_mux_scanner_timer,
                  dvb_adapter_mux_scanner, tda, period);
-    dvb_fe_tune(tda->tda_dn->dn_mux_epg, "EPG scan");
+    dvb_fe_tune(tda->tda_dn->dn_mux_epg->dm_tdmi, "EPG scan");
     return;
 
   }
diff --git a/src/dvb/dvb_fe.c b/src/dvb/dvb_fe.c
index 8d0f6689..97c1c042 100644
--- a/src/dvb/dvb_fe.c
+++ b/src/dvb/dvb_fe.c
@@ -277,7 +277,7 @@ dvb_fe_stop(th_dvb_mux_instance_t *tdmi, int retune)
 
   assert(tdmi->tdmi_scan_queue == NULL);
 
-  epggrab_mux_stop(tdmi, 0);
+  epggrab_mux_stop(tdmi->tdmi_mux, 0);
 
   if (!retune) {
     gtimer_disarm(&tda->tda_fe_monitor_timer);
@@ -512,8 +512,8 @@ dvb_fe_tune(th_dvb_mux_instance_t *tdmi, const char *reason)
   gtimer_arm(&tda->tda_fe_monitor_timer, dvb_fe_monitor, tda, 1);
 
 
-  dvb_table_add_default(tdmi);
-  epggrab_mux_start(tdmi);
+  dvb_table_add_default(tdmi->tdmi_mux);
+  epggrab_mux_start(tdmi->tdmi_mux);
 
   dvb_adapter_notify(tda);
   return 0;
diff --git a/src/dvb/dvb_multiplex.c b/src/dvb/dvb_multiplex.c
index 2a69cc6a..a85bf6fc 100644
--- a/src/dvb/dvb_multiplex.c
+++ b/src/dvb/dvb_multiplex.c
@@ -228,11 +228,14 @@ dvb_mux_create(th_dvb_adapter_t *tda, const struct dvb_mux_conf *dmc,
   dm->dm_network_id = onid;
   dm->dm_transport_stream_id = tsid;
   dm->dm_network_name = network ? strdup(network) : NULL;
-  dm->dm_dn = tda->tda_dn;
+  TAILQ_INIT(&dm->dm_epg_grab);
 
+  dm->dm_dn = tda->tda_dn;
+  LIST_INSERT_HEAD(&tda->tda_dn->dn_muxes, dm, dm_network_link);
 
   tdmi = calloc(1, sizeof(th_dvb_mux_instance_t));
   tdmi->tdmi_mux = dm;
+  dm->dm_tdmi = tdmi;
 
   if(identifier == NULL) {
     char qpsktxt[20];
@@ -263,7 +266,6 @@ dvb_mux_create(th_dvb_adapter_t *tda, const struct dvb_mux_conf *dmc,
     return NULL;
   }
 
-  TAILQ_INIT(&tdmi->tdmi_epg_grab);
 
   tdmi->tdmi_enabled = enabled;
   
@@ -332,7 +334,7 @@ dvb_mux_destroy(th_dvb_mux_instance_t *tdmi)
   if(tdmi->tdmi_table_initial)
     tda->tda_dn->dn_initial_num_mux--;
 
-  epggrab_mux_delete(tdmi);
+  epggrab_mux_delete(tdmi->tdmi_mux); // XXX(dvbreorg)
 
   hts_settings_remove("dvbmuxes/%s", tdmi->tdmi_identifier);
 
@@ -810,12 +812,15 @@ dvb_mux_load(th_dvb_adapter_t *tda)
  *
  */
 void
-dvb_mux_set_networkname(th_dvb_mux_instance_t *tdmi, const char *networkname)
+dvb_mux_set_networkname(dvb_mux_t *dm, const char *networkname)
 {
   htsmsg_t *m;
 
-  free(tdmi->tdmi_mux->dm_network_name);
-  tdmi->tdmi_mux->dm_network_name = strdup(networkname);
+  free(dm->dm_network_name);
+  dm->dm_network_name = strdup(networkname);
+
+  th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
+
   dvb_mux_save(tdmi);
 
   m = htsmsg_create_map();
@@ -829,12 +834,14 @@ dvb_mux_set_networkname(th_dvb_mux_instance_t *tdmi, const char *networkname)
  *
  */
 void
-dvb_mux_set_tsid(th_dvb_mux_instance_t *tdmi, uint16_t tsid)
+dvb_mux_set_tsid(dvb_mux_t *dm, uint16_t tsid)
 {
   htsmsg_t *m;
 
-  tdmi->tdmi_mux->dm_transport_stream_id = tsid;
- 
+  dm->dm_transport_stream_id = tsid;
+
+  th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
+
   dvb_mux_save(tdmi);
 
   m = htsmsg_create_map();
@@ -847,12 +854,14 @@ dvb_mux_set_tsid(th_dvb_mux_instance_t *tdmi, uint16_t tsid)
  *
  */
 void
-dvb_mux_set_onid(th_dvb_mux_instance_t *tdmi, uint16_t onid)
+dvb_mux_set_onid(dvb_mux_t *dm, uint16_t onid)
 {
   htsmsg_t *m;
 
-  tdmi->tdmi_mux->dm_network_id = onid;
- 
+  dm->dm_network_id = onid;
+
+  th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
+
   dvb_mux_save(tdmi);
 
   m = htsmsg_create_map();
diff --git a/src/dvb/dvb_service.c b/src/dvb/dvb_service.c
index 088d2d22..b5d55794 100644
--- a/src/dvb/dvb_service.c
+++ b/src/dvb/dvb_service.c
@@ -97,7 +97,7 @@ dvb_service_start(service_t *t, unsigned int weight, int force_start)
   if(!r)
     tda->tda_open_service(tda, t);
 
-  dvb_table_add_pmt(t->s_dvb_mux_instance, t->s_pmt_pid);
+  dvb_table_add_pmt(t->s_dvb_mux_instance->tdmi_mux, t->s_pmt_pid);
 
   return r;
 }
diff --git a/src/dvb/dvb_tables.c b/src/dvb/dvb_tables.c
index 94f6fb2b..3708d025 100644
--- a/src/dvb/dvb_tables.c
+++ b/src/dvb/dvb_tables.c
@@ -86,6 +86,7 @@ dvb_table_dispatch(uint8_t *sec, int r, th_dvb_table_t *tdt)
   uint8_t *ptr;
   int ret;
   th_dvb_mux_instance_t *tdmi = tdt->tdt_tdmi;
+  dvb_mux_t *dm = tdmi->tdmi_mux;
 
   /* It seems some hardware (or is it the dvb API?) does not
      honour the DMX_CHECK_CRC flag, so we check it again */
@@ -106,12 +107,12 @@ dvb_table_dispatch(uint8_t *sec, int r, th_dvb_table_t *tdt)
   if(chkcrc) len -= 4;   /* Strip trailing CRC */
 
   if(tdt->tdt_flags & TDT_CA)
-    ret = tdt->tdt_callback((th_dvb_mux_instance_t *)tdt,
-                                sec, len + 3, tableid, tdt->tdt_opaque);
+    ret = tdt->tdt_callback((dvb_mux_t *)tdt,
+                            sec, len + 3, tableid, tdt->tdt_opaque);
   else if(tdt->tdt_flags & TDT_TDT)
-    ret = tdt->tdt_callback(tdt->tdt_tdmi, ptr, len, tableid, tdt);
+    ret = tdt->tdt_callback(dm, ptr, len, tableid, tdt);
   else
-    ret = tdt->tdt_callback(tdt->tdt_tdmi, ptr, len, tableid, tdt->tdt_opaque);
+    ret = tdt->tdt_callback(dm, ptr, len, tableid, tdt->tdt_opaque);
   
   if(ret == 0)
     tdt->tdt_count++;
@@ -154,12 +155,13 @@ dvb_tdt_destroy(th_dvb_adapter_t *tda, th_dvb_mux_instance_t *tdmi,
  * Add a new DVB table
  */
 void
-tdt_add(th_dvb_mux_instance_t *tdmi, int tableid, int mask,
-	int (*callback)(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
+tdt_add(dvb_mux_t *dm, int tableid, int mask,
+	int (*callback)(dvb_mux_t *dm, uint8_t *buf, int len,
 			 uint8_t tableid, void *opaque), void *opaque,
 	const char *name, int flags, int pid)
 {
   th_dvb_table_t *t;
+  th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
 
   // Allow multiple entries per PID, but only one per callback/opaque instance
   // TODO: this could mean reading the same data multiple times, and not
@@ -230,14 +232,14 @@ dvb_desc_def_authority(uint8_t *ptr, int len, char *defauth, size_t dalen)
 }
 
 static int
-dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
+dvb_bat_callback(dvb_mux_t *dm, uint8_t *buf, int len,
 		 uint8_t tableid, void *opaque)
 {
   int i, j, bdlen, tslen, tdlen;
   uint8_t dtag, dlen;
   uint16_t tsid, onid;
   char crid[257];
-  th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
+  dvb_network_t *dn = dm->dm_dn;
 
   if (tableid != 0x4a) return -1;
   bdlen = ((buf[5] & 0xf) << 8) | buf[6];
@@ -266,14 +268,13 @@ dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
     i += 6;
     j = 0;
 
-    /* Find TDMI */
-    LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
-      if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
-         tdmi->tdmi_mux->dm_network_id == onid)
+    /* Find mux */
+    LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
+      if(dm->dm_transport_stream_id == tsid && dm->dm_network_id == onid)
         break;
 
     /* Descriptors */
-    if (tdmi) {
+    if (dm != NULL) {
       int save  = 0;
       *crid = 0;
       while (j+2 < tdlen) {
@@ -288,13 +289,13 @@ dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
         }
         j += dlen;
       }
-      if (*crid && strcmp(tdmi->tdmi_mux->dm_default_authority ?: "", crid)) {
-        free(tdmi->tdmi_mux->dm_default_authority);
-        tdmi->tdmi_mux->dm_default_authority = strdup(crid);
+      if (*crid && strcmp(dm->dm_default_authority ?: "", crid)) {
+        free(dm->dm_default_authority);
+        dm->dm_default_authority = strdup(crid);
         save = 1;
       }
       if (save)
-        dvb_mux_save(tdmi);
+        dvb_mux_save(dm->dm_tdmi);
     }
 
     i += tdlen;
@@ -307,7 +308,7 @@ dvb_bat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len,
  * DVB SDT (Service Description Table)
  */
 static int
-dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_sdt_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
                  uint8_t tableid, void *opaque)
 {
   service_t *t;
@@ -323,7 +324,7 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
   uint8_t stype;
   int l;
 
-  th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
+  dvb_network_t *dn = dm->dm_dn;
 
   if (tableid != 0x42 && tableid != 0x46) return -1;
 
@@ -332,16 +333,16 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
   tsid         = ptr[0] << 8 | ptr[1];
   onid         = ptr[5] << 8 | ptr[6];
   if (tableid == 0x42) {
-    if(tdmi->tdmi_mux->dm_transport_stream_id != tsid)
+    if(dm->dm_transport_stream_id != tsid)
       return -1;
-    if(!tdmi->tdmi_mux->dm_network_id)
-      dvb_mux_set_onid(tdmi, onid);
+    if(!dm->dm_network_id)
+      dvb_mux_set_onid(dm, onid);
   } else {
-    LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
-      if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
-         tdmi->tdmi_mux->dm_network_id != onid)
+    LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
+      if(dm->dm_transport_stream_id == tsid &&
+         dm->dm_network_id != onid)
         break;
-    if (!tdmi) return 0;
+    if (!dm) return 0;
   }
 
   //  version                     = ptr[2] >> 1 & 0x1f;
@@ -373,7 +374,7 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
     if(dllen > len)
       break;
 
-    if (!(t = dvb_service_find(tdmi, service_id, 0, NULL))) {
+    if (!(t = dvb_service_find(dm->dm_tdmi, service_id, 0, NULL))) {
       len -= dllen;
       ptr += dllen;
       continue;
@@ -460,14 +461,14 @@ dvb_sdt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
 /*
  * Combined PID 0x11 callback, for stuff commonly found on that PID
  */
-int dvb_pidx11_callback
-  (th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
-   uint8_t tableid, void *opaque)
+int
+dvb_pidx11_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
+                    uint8_t tableid, void *opaque)
 {
   if (tableid == 0x42 || tableid == 0x46)
-    return dvb_sdt_callback(tdmi, ptr, len, tableid, opaque);
+    return dvb_sdt_callback(dm, ptr, len, tableid, opaque);
   else if (tableid == 0x4a)
-    return dvb_bat_callback(tdmi, ptr, len, tableid, opaque);
+    return dvb_bat_callback(dm, ptr, len, tableid, opaque);
   return -1;
 }
 
@@ -475,11 +476,11 @@ int dvb_pidx11_callback
  * PAT - Program Allocation table
  */
 static int
-dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_pat_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
 		 uint8_t tableid, void *opaque)
 {
-  th_dvb_mux_instance_t *other;
-  th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
+  dvb_mux_t *other;
+  dvb_network_t *dn = dm->dm_dn;
   uint16_t service, pmt, tsid;
 
   if(len < 5)
@@ -495,15 +496,15 @@ dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
   // Make sure this TSID is not already known on another mux
   // That might indicate that we have accedentally received a PAT
   // from another mux
-  LIST_FOREACH(other, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
-    if(other != tdmi &&
-       other->tdmi_mux->dm_transport_stream_id == tsid &&
-       other->tdmi_mux->dm_network_id == tdmi->tdmi_mux->dm_network_id)
+  LIST_FOREACH(other, &dn->dn_muxes, dm_network_link)
+    if(other != dm &&
+       other->dm_transport_stream_id == tsid &&
+       other->dm_network_id == dm->dm_network_id)
       return -1;
 
-  if(tdmi->tdmi_mux->dm_transport_stream_id == 0xffff)
-    dvb_mux_set_tsid(tdmi, tsid);
-  else if (tdmi->tdmi_mux->dm_transport_stream_id != tsid)
+  if(dm->dm_transport_stream_id == 0xffff)
+    dvb_mux_set_tsid(dm, tsid);
+  else if (dm->dm_transport_stream_id != tsid)
     return -1; // TSID mismatches, skip packet, may be from another mux
 
   ptr += 5;
@@ -515,9 +516,9 @@ dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
 
     if(service != 0 && pmt != 0) {
       int save = 0;
-      dvb_service_find2(tdmi, service, pmt, NULL, &save);
-      if (save || !tda->tda_disable_pmt_monitor)
-        dvb_table_add_pmt(tdmi, pmt);
+      dvb_service_find2(dm->dm_tdmi, service, pmt, NULL, &save);
+      if (save || ! dm->dm_tdmi->tdmi_adapter->tda_disable_pmt_monitor)
+        dvb_table_add_pmt(dm, pmt);
     }
     ptr += 4;
     len -= 4;
@@ -530,10 +531,10 @@ dvb_pat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * CA - Conditional Access
  */
 static int
-dvb_ca_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_ca_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
 		uint8_t tableid, void *opaque)
 {
-  cwc_emm(ptr, len, (uintptr_t)opaque, (void *)tdmi);
+  cwc_emm(ptr, len, (uintptr_t)opaque, (void *)dm);
   return 0;
 }
 
@@ -541,8 +542,8 @@ dvb_ca_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * CAT - Conditional Access Table
  */
 static int
-dvb_cat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
-		 uint8_t tableid, void *opaque)
+dvb_cat_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
+                 uint8_t tableid, void *opaque)
 {
   int tag, tlen;
   uint16_t pid;
@@ -568,7 +569,7 @@ dvb_cat_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
       if(pid == 0)
 	break;
 
-      tdt_add(tdmi, 0, 0, dvb_ca_callback, (void *)caid, "CA", 
+      tdt_add(dm, 0, 0, dvb_ca_callback, (void *)caid, "CA", 
 	      TDT_CA, pid);
       break;
 
@@ -613,13 +614,13 @@ static const fe_modulation_t qam_tab [6] = {
  * Cable delivery descriptor
  */
 static int
-dvb_table_cable_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_table_cable_delivery(dvb_mux_t *dm, uint8_t *ptr, int len,
 			 uint16_t tsid, uint16_t onid)
 {
   struct dvb_mux_conf dmc;
   int freq, symrate;
 
-  if(!tdmi->tdmi_adapter->tda_autodiscovery)
+  if(!dm->dm_tdmi->tdmi_adapter->tda_autodiscovery)
     return -1;
 
   if(len < 11)
@@ -651,7 +652,7 @@ dvb_table_cable_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
 
   dmc.dmc_fe_params.u.qam.fec_inner = fec_tab[ptr[10] & 0x07];
 
-  dvb_mux_create(tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
+  dvb_mux_create(dm->dm_tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
 		 "automatic mux discovery", 1, 1, NULL);
   return 0;
 }
@@ -660,14 +661,14 @@ dvb_table_cable_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * Satellite delivery descriptor
  */
 static int
-dvb_table_sat_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_table_sat_delivery(dvb_mux_t *dm, uint8_t *ptr, int len,
 		       uint16_t tsid, uint16_t onid)
 {
   int freq, symrate;
   //  uint16_t orbital_pos;
   struct dvb_mux_conf dmc;
 
-  if(!tdmi->tdmi_adapter->tda_autodiscovery)
+  if(!dm->dm_tdmi->tdmi_adapter->tda_autodiscovery)
     return -1;
 
   if(len < 11)
@@ -734,7 +735,7 @@ dvb_table_sat_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
   }
 
 #endif
-  dvb_mux_create(tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
+  dvb_mux_create(dm->dm_tdmi->tdmi_adapter, &dmc, onid, tsid, NULL,
 		 "automatic mux discovery", 1, 1, NULL);
   return 0;
 }
@@ -744,19 +745,18 @@ dvb_table_sat_delivery(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  *
  */
 static void
-dvb_table_local_channel(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_table_local_channel(dvb_mux_t *dm, uint8_t *ptr, int len,
 			uint16_t tsid, uint16_t onid)
 {
   uint16_t sid, chan;
-  th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
+  dvb_network_t *dn = dm->dm_dn;
   service_t *t;
 
-  LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
-    if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
-       tdmi->tdmi_mux->dm_network_id == onid)
+  LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
+    if(dm->dm_transport_stream_id == tsid && dm->dm_network_id == onid)
       break;
 
-  if(tdmi == NULL)
+  if(dm == NULL)
     return;
 
   while(len >= 4) {
@@ -764,7 +764,7 @@ dvb_table_local_channel(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
     chan = ((ptr[2] & 3) << 8) | ptr[3];
 
     if(chan != 0) {
-      t = dvb_service_find(tdmi, sid, 0, NULL);
+      t = dvb_service_find(dm->dm_tdmi, sid, 0, NULL);
       if(t != NULL) {
 
 	if(t->s_channel_number != chan) {
@@ -785,7 +785,7 @@ dvb_table_local_channel(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * NIT - Network Information Table
  */
 static int
-dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_nit_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
 		 uint8_t tableid, void *opaque)
 {
   uint8_t tag, tlen;
@@ -794,11 +794,11 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
   uint16_t tsid, onid;
   uint16_t network_id = (ptr[0] << 8) | ptr[1];
 
-  if(tdmi->tdmi_adapter->tda_nitoid) {
+  if(dm->dm_tdmi->tdmi_adapter->tda_nitoid) {
     if(tableid != 0x41)
       return -1;
     
-    if(network_id != tdmi->tdmi_adapter->tda_nitoid)
+    if(network_id != dm->dm_tdmi->tdmi_adapter->tda_nitoid)
       return -1;
 
   } else {
@@ -831,8 +831,8 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
       if(dvb_get_string(networkname, sizeof(networkname), ptr, tlen, NULL, NULL))
 	return -1;
 
-      if(strcmp(tdmi->tdmi_mux->dm_network_name ?: "", networkname))
-	dvb_mux_set_networkname(tdmi, networkname);
+      if(strcmp(dm->dm_network_name ?: "", networkname))
+	dvb_mux_set_networkname(dm, networkname);
       break;
     }
 
@@ -869,15 +869,15 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
 
       switch(tag) {
       case DVB_DESC_SAT:
-        if(tdmi->tdmi_adapter->tda_fe_type == FE_QPSK)
-          dvb_table_sat_delivery(tdmi, ptr, tlen, tsid, onid);
+        if(dm->dm_dn->dn_fe_type == FE_QPSK)
+          dvb_table_sat_delivery(dm, ptr, tlen, tsid, onid);
         break;
       case DVB_DESC_CABLE:
-        if(tdmi->tdmi_adapter->tda_fe_type == FE_QAM)
-          dvb_table_cable_delivery(tdmi, ptr, tlen, tsid, onid);
+        if(dm->dm_dn->dn_fe_type == FE_QAM)
+          dvb_table_cable_delivery(dm, ptr, tlen, tsid, onid);
         break;
       case DVB_DESC_LOCAL_CHAN:
-        dvb_table_local_channel(tdmi, ptr, tlen, tsid, onid);
+        dvb_table_local_channel(dm, ptr, tlen, tsid, onid);
         break;
       }
 
@@ -894,10 +894,10 @@ dvb_nit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * VCT - ATSC Virtual Channel Table
  */
 static int
-atsc_vct_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+atsc_vct_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
 		  uint8_t tableid, void *opaque)
 {
-  th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
+  dvb_network_t *dn = dm->dm_dn;
   service_t *t;
   int numch;
   char chname[256];
@@ -932,16 +932,15 @@ atsc_vct_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
     onid = (ptr[24] << 8) | ptr[25];
     
     /* Search all muxes on adapter */
-    LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link)
-      if(tdmi->tdmi_mux->dm_transport_stream_id == tsid &&
-         tdmi->tdmi_mux->dm_network_id == onid);
+    LIST_FOREACH(dm, &dn->dn_muxes, dm_network_link)
+      if(dm->dm_transport_stream_id == tsid && dm->dm_network_id == onid);
 	break;
     
-    if(tdmi == NULL)
+    if(dm == NULL)
       continue;
 
     service_id = (ptr[24] << 8) | ptr[25];
-    if((t = dvb_service_find(tdmi, service_id, 0, NULL)) == NULL)
+    if((t = dvb_service_find(dm->dm_tdmi, service_id, 0, NULL)) == NULL)
       continue;
 
     atsc_stype = ptr[27] & 0x3f;
@@ -979,12 +978,13 @@ atsc_vct_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * PMT - Program Mapping Table
  */
 static int
-dvb_pmt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
+dvb_pmt_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
 		 uint8_t tableid, void *opaque)
 {
   int active = 0;
   service_t *t;
   th_dvb_table_t *tdt = opaque;
+  th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
 
   LIST_FOREACH(t, &tdmi->tdmi_mux->dm_services, s_group_link) {
     pthread_mutex_lock(&t->s_stream_mutex);
@@ -1005,23 +1005,23 @@ dvb_pmt_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
  * Demux for default DVB tables that we want
  */
 static void
-dvb_table_add_default_dvb(th_dvb_mux_instance_t *tdmi)
+dvb_table_add_default_dvb(dvb_mux_t *dm)
 {
   /* Network Information Table */
 
   int table;
 
-  if(tdmi->tdmi_adapter->tda_nitoid) {
+  if(dm->dm_tdmi->tdmi_adapter->tda_nitoid) {
     table = 0x41;
   } else {
     table = 0x40;
   }
-  tdt_add(tdmi, table, 0xff, dvb_nit_callback, NULL, "nit", 
+  tdt_add(dm, table, 0xff, dvb_nit_callback, NULL, "nit", 
 	  TDT_QUICKREQ | TDT_CRC, 0x10);
 
   /* Service Descriptor Table and Bouqeut Allocation Table */
 
-  tdt_add(tdmi, 0, 0, dvb_pidx11_callback, NULL, "pidx11", 
+  tdt_add(dm, 0, 0, dvb_pidx11_callback, NULL, "pidx11", 
 	  TDT_QUICKREQ | TDT_CRC, 0x11);
 }
 
@@ -1030,17 +1030,17 @@ dvb_table_add_default_dvb(th_dvb_mux_instance_t *tdmi)
  * Demux for default ATSC tables that we want
  */
 static void
-dvb_table_add_default_atsc(th_dvb_mux_instance_t *tdmi)
+dvb_table_add_default_atsc(dvb_mux_t *dm)
 {
   int tableid;
 
-  if(tdmi->tdmi_mux->dm_conf.dmc_fe_params.u.vsb.modulation == VSB_8) {
+  if(dm->dm_conf.dmc_fe_params.u.vsb.modulation == VSB_8) {
     tableid = 0xc8; // Terrestrial
   } else {
     tableid = 0xc9; // Cable
   }
 
-  tdt_add(tdmi, tableid, 0xff, atsc_vct_callback, NULL, "vct",
+  tdt_add(dm, tableid, 0xff, atsc_vct_callback, NULL, "vct",
 	  TDT_QUICKREQ | TDT_CRC, 0x1ffb);
 }
 
@@ -1051,26 +1051,26 @@ dvb_table_add_default_atsc(th_dvb_mux_instance_t *tdmi)
  * Setup FD + demux for default tables that we want
  */
 void
-dvb_table_add_default(th_dvb_mux_instance_t *tdmi)
+dvb_table_add_default(dvb_mux_t *dm)
 {
   /* Program Allocation Table */
-  tdt_add(tdmi, 0x00, 0xff, dvb_pat_callback, NULL, "pat", 
+  tdt_add(dm, 0x00, 0xff, dvb_pat_callback, NULL, "pat", 
 	  TDT_QUICKREQ | TDT_CRC, 0);
 
   /* Conditional Access Table */
-  tdt_add(tdmi, 0x1, 0xff, dvb_cat_callback, NULL, "cat", 
+  tdt_add(dm, 0x1, 0xff, dvb_cat_callback, NULL, "cat", 
 	  TDT_CRC, 1);
 
 
-  switch(tdmi->tdmi_adapter->tda_fe_type) {
+  switch(dm->dm_dn->dn_fe_type) {
   case FE_QPSK:
   case FE_OFDM:
   case FE_QAM:
-    dvb_table_add_default_dvb(tdmi);
+    dvb_table_add_default_dvb(dm);
     break;
 
   case FE_ATSC:
-    dvb_table_add_default_atsc(tdmi);
+    dvb_table_add_default_atsc(dm);
     break;
   }
 }
@@ -1080,24 +1080,26 @@ dvb_table_add_default(th_dvb_mux_instance_t *tdmi)
  * Setup FD + demux for a services PMT
  */
 void
-dvb_table_add_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid)
+dvb_table_add_pmt(dvb_mux_t *dm, int pmt_pid)
 {
   char pmtname[100];
 
   snprintf(pmtname, sizeof(pmtname), "PMT(%d)", pmt_pid);
-  tdt_add(tdmi, 0x2, 0xff, dvb_pmt_callback, NULL, pmtname, 
+  tdt_add(dm, 0x2, 0xff, dvb_pmt_callback, NULL, pmtname, 
 	  TDT_CRC | TDT_QUICKREQ | TDT_TDT, pmt_pid);
 }
 
 void
-dvb_table_rem_pmt(th_dvb_mux_instance_t *tdmi, int pmt_pid)
+dvb_table_rem_pmt(dvb_mux_t *dm, int pmt_pid)
 {
+  th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
   th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
   th_dvb_table_t *tdt = NULL;
   LIST_FOREACH(tdt, &tdmi->tdmi_tables, tdt_link)
     if (tdt->tdt_pid == pmt_pid && tdt->tdt_callback == dvb_pmt_callback)
       break;
-  if (tdt) dvb_tdt_destroy(tda, tdmi, tdt);
+  if (tdt)
+    dvb_tdt_destroy(tda, tdmi, tdt);
 }
 
 
diff --git a/src/epggrab.h b/src/epggrab.h
index ddb46a41..d72f98d6 100644
--- a/src/epggrab.h
+++ b/src/epggrab.h
@@ -169,10 +169,10 @@ struct epggrab_module_ext
  */
 struct epggrab_ota_mux
 {
-  TAILQ_ENTRY(epggrab_ota_mux)       glob_link; ///< Grabber link
-  TAILQ_ENTRY(epggrab_ota_mux)       tdmi_link; ///< Link to mux
-  TAILQ_ENTRY(epggrab_ota_mux)       grab_link; ///< Link to grabber
-  struct th_dvb_mux_instance        *tdmi;     ///< Mux  instance
+  TAILQ_ENTRY(epggrab_ota_mux)       glob_link;///< Grabber link
+  TAILQ_ENTRY(epggrab_ota_mux)       dm_link;  ///< Link to dvb mux
+  TAILQ_ENTRY(epggrab_ota_mux)       grab_link;///< Link to grabber
+  struct dvb_mux                    *dm;       ///< Mux  instance
   epggrab_module_ota_t              *grab;     ///< Grab instance
 
   int                               timeout;   ///< Time out if this long
@@ -203,7 +203,7 @@ struct epggrab_module_ota
   TAILQ_HEAD(, epggrab_ota_mux)  muxes; ///< List of related muxes
 
   /* Transponder tuning */
-  void (*start) ( epggrab_module_ota_t *m, struct th_dvb_mux_instance *tdmi );
+  void (*start) ( epggrab_module_ota_t *m, struct dvb_mux *dm );
 };
 
 /*
@@ -259,11 +259,11 @@ void epggrab_channel_mod ( struct channel *ch );
 /*
  * Transport handling
  */
-void epggrab_mux_start  ( struct th_dvb_mux_instance *tdmi );
-void epggrab_mux_stop   ( struct th_dvb_mux_instance *tdmi, int timeout );
-void epggrab_mux_delete ( struct th_dvb_mux_instance *tdmi );
-int  epggrab_mux_period ( struct th_dvb_mux_instance *tdmi );
-struct th_dvb_mux_instance *epggrab_mux_next ( struct th_dvb_adapter *tda );
+void epggrab_mux_start  ( struct dvb_mux *tdmi );
+void epggrab_mux_stop   ( struct dvb_mux *tdmi, int timeout );
+void epggrab_mux_delete ( struct dvb_mux *tdmi );
+int  epggrab_mux_period ( struct dvb_mux *tdmi );
+struct dvb_mux *epggrab_mux_next ( struct th_dvb_adapter *tda );
 
 /*
  * Re-schedule
diff --git a/src/epggrab/module.c b/src/epggrab/module.c
index b920eea1..788dd8ab 100644
--- a/src/epggrab/module.c
+++ b/src/epggrab/module.c
@@ -457,7 +457,7 @@ epggrab_module_ota_t *epggrab_module_ota_create
   ( epggrab_module_ota_t *skel,
     const char *id, const char *name, int priority,
     void (*start) (epggrab_module_ota_t*m,
-                   struct th_dvb_mux_instance *tdmi),
+                   struct dvb_mux *dm),
     int (*enable) (void *m, uint8_t e ),
     epggrab_channel_tree_t *channels )
 {
diff --git a/src/epggrab/module/eit.c b/src/epggrab/module/eit.c
index 9d1b2cab..a2663af6 100644
--- a/src/epggrab/module/eit.c
+++ b/src/epggrab/module/eit.c
@@ -654,9 +654,9 @@ static int _eit_process_event
   return ret;
 }
 
-static int _eit_callback
-  ( th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len, 
-    uint8_t tableid, void *opaque )
+static int
+_eit_callback(dvb_mux_t *dm, uint8_t *ptr, int len,
+              uint8_t tableid, void *opaque)
 {
   epggrab_module_t *mod = opaque;
   epggrab_ota_mux_t *ota;
@@ -672,7 +672,7 @@ static int _eit_callback
   if(tableid < 0x4e || tableid > 0x6f || len < 11) return -1;
 
   /* Get OTA */
-  ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi);
+  ota = epggrab_ota_find((epggrab_module_ota_t*)mod, dm);
   if (!ota || !ota->status) return -1;
   sta = ota->status;
 
@@ -713,24 +713,26 @@ static int _eit_callback
   // Note: tableid=0x4f,0x60-0x6f is other TS
   //       so must find the tdmi
   if(tableid == 0x4f || tableid >= 0x60) {
-    tda  = tdmi->tdmi_adapter;
-    tdmi = dvb_mux_find(tda, NULL, onid, tsid, 1);
+    tda  = dm->dm_tdmi->tdmi_adapter;
+    th_dvb_mux_instance_t *tdmi = dvb_mux_find(tda, NULL, onid, tsid, 1);
+    dm = tdmi->tdmi_mux;
+
   } else {
-    if (tdmi->tdmi_mux->dm_transport_stream_id != tsid ||
-        tdmi->tdmi_mux->dm_network_id != onid) {
+    if (dm->dm_transport_stream_id != tsid ||
+        dm->dm_network_id != onid) {
 #ifdef EPG_EIT_TRACE
       tvhlog(LOG_DEBUG, mod->id,
              "invalid transport id found tid 0x%02X, onid:tsid %d:%d != %d:%d",
              tableid, tdmi->tdmi_network_id, tdmi->tdmi_transport_stream_id,
              onid, tsid);
 #endif
-      tdmi = NULL;
+      dm = NULL;
     }
   }
-  if(!tdmi) goto done;
+  if(!dm) goto done;
 
   /* Get service */
-  svc = dvb_service_find3(NULL, tdmi, NULL, 0, 0, sid, 1, 1);
+  svc = dvb_service_find3(NULL, dm->dm_tdmi, NULL, 0, 0, sid, 1, 1);
   if (!svc || !svc->s_ch) goto done;
 
   /* Register as interesting */
@@ -815,10 +817,9 @@ static void _eit_ota_destroy ( epggrab_ota_mux_t *ota )
 }
 
 static void _eit_start 
-  ( epggrab_module_ota_t *m, th_dvb_mux_instance_t *tdmi )
+  ( epggrab_module_ota_t *m, dvb_mux_t *dm )
 {
   epggrab_ota_mux_t *ota;
-
   /* Disabled */
   if (!m->enabled) return;
 
@@ -830,7 +831,7 @@ static void _eit_start
   }
 
   /* Register */
-  if (!(ota = epggrab_ota_create(m, tdmi))) return;
+  if (!(ota = epggrab_ota_create(m, dm))) return;
   if (!ota->status) {
     ota->status  = calloc(1, sizeof(eit_status_t));
     ota->destroy = _eit_ota_destroy;
@@ -842,16 +843,16 @@ static void _eit_start
     tdt_add(tdmi, 0, 0, dvb_pidx11_callback, m, m->id, TDT_CRC, 3840, NULL);
     tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 3841, NULL);
 #endif
-    tdt_add(tdmi, 0, 0, dvb_pidx11_callback, m, m->id, TDT_CRC, 3002);
-    tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 3003);
+    tdt_add(dm, 0, 0, dvb_pidx11_callback, m, m->id, TDT_CRC, 3002);
+    tdt_add(dm, 0, 0, _eit_callback, m, m->id, TDT_CRC, 3003);
 
   /* Viasat Baltic (0x39) */
   } else if (!strcmp("viasat_baltic", m->id)) {
-    tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x39);
+    tdt_add(dm, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x39);
 
   /* Standard (0x12) */
   } else {
-    tdt_add(tdmi, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x12);
+    tdt_add(dm, 0, 0, _eit_callback, m, m->id, TDT_CRC, 0x12);
   }
   tvhlog(LOG_DEBUG, m->id, "install table handlers");
 }
diff --git a/src/epggrab/module/opentv.c b/src/epggrab/module/opentv.c
index 20ed1d7a..51cc3ef2 100644
--- a/src/epggrab/module/opentv.c
+++ b/src/epggrab/module/opentv.c
@@ -519,11 +519,11 @@ static int _opentv_bat_section
  * ***********************************************************************/
 
 static epggrab_ota_mux_t *_opentv_event_callback 
-  ( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
+  ( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
 {
   th_dvb_table_t    *tdt = p;
   opentv_module_t   *mod = tdt->tdt_opaque;
-  epggrab_ota_mux_t *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi);
+  epggrab_ota_mux_t *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, dm);
   opentv_status_t *sta;
   opentv_pid_t *pid;
 
@@ -584,9 +584,9 @@ static epggrab_ota_mux_t *_opentv_event_callback
 }
 
 static int _opentv_title_callback
-  ( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
+  ( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
 {
-  epggrab_ota_mux_t *ota = _opentv_event_callback(tdmi, buf, len, tid, p);
+  epggrab_ota_mux_t *ota = _opentv_event_callback(dm, buf, len, tid, p);
   if (ota)
     return _opentv_parse_event_section((opentv_module_t*)ota->grab,
                                        (opentv_status_t*)ota->status,
@@ -595,9 +595,9 @@ static int _opentv_title_callback
 }
 
 static int _opentv_summary_callback
-  ( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
+  ( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
 {
-  epggrab_ota_mux_t *ota = _opentv_event_callback(tdmi, buf, len, tid, p);
+  epggrab_ota_mux_t *ota = _opentv_event_callback(dm, buf, len, tid, p);
   if (ota)
     return _opentv_parse_event_section((opentv_module_t*)ota->grab,
                                        (opentv_status_t*)ota->status,
@@ -606,10 +606,10 @@ static int _opentv_summary_callback
 }
 
 static int _opentv_channel_callback
-  ( th_dvb_mux_instance_t *tdmi, uint8_t *buf, int len, uint8_t tid, void *p )
+  ( dvb_mux_t *dm, uint8_t *buf, int len, uint8_t tid, void *p )
 {
   opentv_module_t      *mod = p;
-  epggrab_ota_mux_t    *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi);
+  epggrab_ota_mux_t    *ota = epggrab_ota_find((epggrab_module_ota_t*)mod, dm);
   opentv_status_t      *sta;
   if (!ota || !ota->status) return 0;
   sta = ota->status;
@@ -642,7 +642,7 @@ static void _opentv_ota_destroy ( epggrab_ota_mux_t *ota )
 }
 
 static void _opentv_start
-  ( epggrab_module_ota_t *m, th_dvb_mux_instance_t *tdmi )
+  ( epggrab_module_ota_t *m, dvb_mux_t *dm )
 {
   int *t;
   epggrab_ota_mux_t *ota;
@@ -651,10 +651,10 @@ static void _opentv_start
 
   /* Ignore */
   if (!m->enabled)  return;
-  if (mod->tsid != tdmi->tdmi_mux->dm_transport_stream_id) return;
+  if (mod->tsid != dm->dm_transport_stream_id) return;
 
   /* Create link */
-  if (!(ota = epggrab_ota_create(m, tdmi))) return;
+  if (!(ota = epggrab_ota_create(m, dm))) return;
   if (!ota->status) {
     ota->status  = calloc(1, sizeof(opentv_status_t));
     ota->destroy = _opentv_ota_destroy;
@@ -672,7 +672,7 @@ static void _opentv_start
   t = mod->channel;
   while (*t) {
     // TODO: what about 0x46 (service description)
-    tdt_add(tdmi, 0x4a, 0xff, _opentv_channel_callback, m,
+    tdt_add(dm, 0x4a, 0xff, _opentv_channel_callback, m,
             m->id, TDT_CRC, *t++);
   }
 
@@ -680,7 +680,7 @@ static void _opentv_start
   t = mod->title;
   while (*t) {
     _opentv_status_get_pid(sta, *t);
-    tdt_add(tdmi, 0xa0, 0xfc, _opentv_title_callback, m,
+    tdt_add(dm, 0xa0, 0xfc, _opentv_title_callback, m,
             m->id, TDT_CRC | TDT_TDT, *t++);
   }
 
@@ -688,7 +688,7 @@ static void _opentv_start
   t = mod->summary;
   while (*t) {
     _opentv_status_get_pid(sta, *t);
-    tdt_add(tdmi, 0xa8, 0xfc, _opentv_summary_callback, m,
+    tdt_add(dm, 0xa8, 0xfc, _opentv_summary_callback, m,
             m->id, TDT_CRC | TDT_TDT, *t++);
   }
 }
diff --git a/src/epggrab/otamux.c b/src/epggrab/otamux.c
index 6d3a23cd..9fa07b67 100644
--- a/src/epggrab/otamux.c
+++ b/src/epggrab/otamux.c
@@ -36,27 +36,27 @@ TAILQ_HEAD(, epggrab_ota_mux) ota_mux_all;
  * Global functions (called from DVB code)
  * *************************************************************************/
 
-void epggrab_mux_start ( th_dvb_mux_instance_t *tdmi )
+void epggrab_mux_start ( dvb_mux_t *dm )
 {
   epggrab_module_t *m;
   epggrab_module_ota_t *om;
   LIST_FOREACH(m, &epggrab_modules, link) {
     if (m->type == EPGGRAB_OTA) {
       om = (epggrab_module_ota_t*)m;
-      if (om->start) om->start(om, tdmi);
+      if (om->start) om->start(om, dm);
     }
   }
 }
 
-void epggrab_mux_stop ( th_dvb_mux_instance_t *tdmi, int timeout )
+void epggrab_mux_stop ( dvb_mux_t *dm, int timeout )
 {
   // Note: the slightly akward list iteration here is because
   // _ota_cancel/delete can remove the object and free() it
   epggrab_ota_mux_t *a, *b;
-  a = TAILQ_FIRST(&tdmi->tdmi_epg_grab);
+  a = TAILQ_FIRST(&dm->dm_epg_grab);
   while (a) {
-    b = TAILQ_NEXT(a, tdmi_link);
-    if (a->tdmi == tdmi) {
+    b = TAILQ_NEXT(a, dm_link);
+    if (a->dm == dm) {
       if (timeout)
         epggrab_ota_timeout(a);
       else
@@ -66,16 +66,16 @@ void epggrab_mux_stop ( th_dvb_mux_instance_t *tdmi, int timeout )
   }
 }
 
-void epggrab_mux_delete ( th_dvb_mux_instance_t *tdmi )
+void epggrab_mux_delete ( dvb_mux_t *dm )
 {
-  epggrab_ota_destroy_by_tdmi(tdmi);
+  epggrab_ota_destroy_by_dm(dm);
 }
 
-int epggrab_mux_period ( th_dvb_mux_instance_t *tdmi )
+int epggrab_mux_period ( dvb_mux_t *dm )
 {
   int period = 0;
   epggrab_ota_mux_t *ota;
-  TAILQ_FOREACH(ota, &tdmi->tdmi_epg_grab, tdmi_link) {
+  TAILQ_FOREACH(ota, &dm->dm_epg_grab, dm_link) {
     if (!ota->is_reg) continue;
     if (ota->timeout > period)
       period = ota->timeout;
@@ -83,7 +83,7 @@ int epggrab_mux_period ( th_dvb_mux_instance_t *tdmi )
   return period;
 }
 
-th_dvb_mux_instance_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
+dvb_mux_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
 {
   time_t now;
   epggrab_ota_mux_t *ota;
@@ -91,9 +91,9 @@ th_dvb_mux_instance_t *epggrab_mux_next ( th_dvb_adapter_t *tda )
   TAILQ_FOREACH(ota, &ota_mux_all, glob_link) {
     if (ota->interval + ota->completed > now) return NULL;
     if (!ota->is_reg) return NULL;
-    if (ota->tdmi->tdmi_adapter == tda) break;
+    if (ota->dm->dm_tdmi->tdmi_adapter == tda) break;
   }
-  return ota ? ota->tdmi : NULL;
+  return ota ? ota->dm : NULL;
 }
 
 /* **************************************************************************
@@ -148,7 +148,7 @@ static void _epggrab_ota_save_one ( htsmsg_t *m, epggrab_module_ota_t *mod )
     if (!l) l = htsmsg_create_list();
     e = htsmsg_create_map();
 
-    const dvb_mux_t *dm = ota->tdmi->tdmi_mux;
+    const dvb_mux_t *dm = ota->dm;
 
     htsmsg_add_u32(e, "onid",     dm->dm_network_id);
     htsmsg_add_u32(e, "tsid",     dm->dm_transport_stream_id);
@@ -212,11 +212,11 @@ static int _ota_time_cmp ( void *_a, void *_b )
  * Find existing link
  */
 epggrab_ota_mux_t *epggrab_ota_find
-  ( epggrab_module_ota_t *mod, th_dvb_mux_instance_t *tdmi )
+  ( epggrab_module_ota_t *mod, dvb_mux_t *dm )
 {
   epggrab_ota_mux_t *ota;
   TAILQ_FOREACH(ota, &mod->muxes, grab_link) {
-    if (ota->tdmi == tdmi) break;
+    if (ota->dm == dm) break;
   }
   return ota;
 }
@@ -225,18 +225,18 @@ epggrab_ota_mux_t *epggrab_ota_find
  * Create (temporary) or Find (existing) link
  */
 epggrab_ota_mux_t *epggrab_ota_create
-  ( epggrab_module_ota_t *mod, th_dvb_mux_instance_t *tdmi )
+  ( epggrab_module_ota_t *mod, dvb_mux_t *dm)
 {
   /* Search for existing */
-  epggrab_ota_mux_t *ota = epggrab_ota_find(mod, tdmi);
+  epggrab_ota_mux_t *ota = epggrab_ota_find(mod, dm);
 
   /* Create new */
   if (!ota) {
     ota = calloc(1, sizeof(epggrab_ota_mux_t));
     ota->grab  = mod;
-    ota->tdmi  = tdmi;
+    ota->dm    = dm;
     TAILQ_INSERT_TAIL(&ota_mux_all, ota, glob_link);
-    TAILQ_INSERT_TAIL(&tdmi->tdmi_epg_grab, ota, tdmi_link);
+    TAILQ_INSERT_TAIL(&dm->dm_epg_grab, ota, dm_link);
     TAILQ_INSERT_TAIL(&mod->muxes, ota, grab_link);
 
   } else {
@@ -259,12 +259,12 @@ void epggrab_ota_create_and_register_by_id
   epggrab_ota_mux_t *ota;
   TAILQ_FOREACH(tda, &dvb_adapters, tda_global_link) {
     LIST_FOREACH(tdmi, &tda->tda_dn->dn_mux_instances, tdmi_adapter_link) {
-      const dvb_mux_t *dm = tdmi->tdmi_mux;
+      dvb_mux_t *dm = tdmi->tdmi_mux;
       if (dm->dm_transport_stream_id != tsid) continue;
       if (onid && dm->dm_network_id != onid) continue;
       if (networkname && (!dm->dm_network_name ||
                           strcmp(networkname, dm->dm_network_name))) continue;
-      ota = epggrab_ota_create(mod, tdmi);
+      ota = epggrab_ota_create(mod, dm);
       epggrab_ota_register(ota, period, interval);
     }
   }
@@ -276,7 +276,7 @@ void epggrab_ota_create_and_register_by_id
 void epggrab_ota_destroy ( epggrab_ota_mux_t *ota )
 {
   TAILQ_REMOVE(&ota_mux_all, ota, glob_link);
-  TAILQ_REMOVE(&ota->tdmi->tdmi_epg_grab, ota, tdmi_link);
+  TAILQ_REMOVE(&ota->dm->dm_epg_grab, ota, dm_link);
   TAILQ_REMOVE(&ota->grab->muxes, ota, grab_link);
   if (ota->destroy) ota->destroy(ota);
   else {
@@ -288,10 +288,10 @@ void epggrab_ota_destroy ( epggrab_ota_mux_t *ota )
 /*
  * Destroy by tdmi
  */
-void epggrab_ota_destroy_by_tdmi ( th_dvb_mux_instance_t *tdmi )
+void epggrab_ota_destroy_by_dm ( dvb_mux_t *dm )
 {
   epggrab_ota_mux_t *ota;
-  while ((ota = TAILQ_FIRST(&tdmi->tdmi_epg_grab)))
+  while ((ota = TAILQ_FIRST(&dm->dm_epg_grab)))
     epggrab_ota_destroy(ota);
 }
 
@@ -359,7 +359,7 @@ int epggrab_ota_begin     ( epggrab_ota_mux_t *ota )
 
 void epggrab_ota_complete  ( epggrab_ota_mux_t *ota )
 {
-  th_dvb_mux_instance_t *tdmi = ota->tdmi;
+  dvb_mux_t *dm = ota->dm;
 
   if (ota->state != EPGGRAB_OTA_MUX_COMPLETE) {
     tvhlog(LOG_DEBUG, ota->grab->id, "processing complete");
@@ -367,12 +367,13 @@ void epggrab_ota_complete  ( epggrab_ota_mux_t *ota )
     time(&ota->completed);
 
     /* Check others */
-    TAILQ_FOREACH(ota, &tdmi->tdmi_epg_grab, tdmi_link) {
+    TAILQ_FOREACH(ota, &dm->dm_epg_grab, dm_link) {
       if (ota->is_reg && ota->state == EPGGRAB_OTA_MUX_RUNNING) break;
     }
 
     /* All complete (bring timer forward) */
     if (!ota) {
+      th_dvb_mux_instance_t *tdmi = dm->dm_tdmi;
       gtimer_arm(&tdmi->tdmi_adapter->tda_mux_scanner_timer,
                  dvb_adapter_mux_scanner, tdmi->tdmi_adapter, 20);
     }
diff --git a/src/epggrab/private.h b/src/epggrab/private.h
index a9625862..7ce58ea1 100644
--- a/src/epggrab/private.h
+++ b/src/epggrab/private.h
@@ -88,7 +88,7 @@ epggrab_module_ota_t *epggrab_module_ota_create
   ( epggrab_module_ota_t *skel,
     const char *id, const char *name, int priority,
     void (*start) (epggrab_module_ota_t*m,
-                   struct th_dvb_mux_instance *tdmi),
+                   struct dvb_mux *dm),
     int (*enable) (void *m, uint8_t e ),
     epggrab_channel_tree_t *channels );
 
@@ -109,9 +109,9 @@ void epggrab_ota_save ( void );
  *       blocked (i.e. has completed within interval period)
  */
 epggrab_ota_mux_t *epggrab_ota_find
-  ( epggrab_module_ota_t *mod, struct th_dvb_mux_instance *tdmi );
+  ( epggrab_module_ota_t *mod, struct dvb_mux *dm );
 epggrab_ota_mux_t *epggrab_ota_create
-  ( epggrab_module_ota_t *mod, struct th_dvb_mux_instance *tdmi );
+  ( epggrab_module_ota_t *mod, struct dvb_mux *dm );
 void epggrab_ota_create_and_register_by_id
   ( epggrab_module_ota_t *mod, int nid, int tsid,
     int period, int interval, const char *name );
@@ -121,7 +121,7 @@ void epggrab_ota_create_and_register_by_id
  */
 void epggrab_ota_destroy           ( epggrab_ota_mux_t *ota );
 void epggrab_ota_destroy_by_module ( epggrab_module_ota_t *mod );
-void epggrab_ota_destroy_by_tdmi   ( struct th_dvb_mux_instance *tdmi );
+void epggrab_ota_destroy_by_dm     ( struct dvb_mux *dm );
 
 /*
  * Register interest