diff --git a/src/dvb/dvb_tables.c b/src/dvb/dvb_tables.c
index 7ab0568c..da08b54e 100644
--- a/src/dvb/dvb_tables.c
+++ b/src/dvb/dvb_tables.c
@@ -448,7 +448,7 @@ static int
 dvb_eit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
 		 uint8_t tableid, void *opaque)
 {
-#if TODO
+#ifdef TODO_EIT_GRABBER
   service_t *t;
   channel_t *ch;
   th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
@@ -469,8 +469,6 @@ dvb_eit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
   char extitem[5000];
   char exttext[5000];
 
-  event_t *e;
-
   lock_assert(&global_lock);
 
   //  printf("EIT!, tid = %x\n", tableid);
diff --git a/src/dvr/dvr.h b/src/dvr/dvr.h
index b91a1b90..0db0c7b1 100644
--- a/src/dvr/dvr.h
+++ b/src/dvr/dvr.h
@@ -124,11 +124,13 @@ typedef struct dvr_entry {
 
   dvr_prio_t de_pri;
 
-  epg_episode_t de_episode;
-  uint8_t de_content_type;
-
   uint32_t de_dont_reschedule;
 
+  /**
+   * EPG information / links
+   */
+  epg_broadcast_t *de_bcast;
+
   /**
    * Major State
    */
@@ -188,6 +190,8 @@ typedef struct dvr_autorec_entry {
   char *dae_creator;
   char *dae_comment;
 
+// TODO: EPG linking for proper series recording
+
   char *dae_title;
   regex_t dae_title_preg;
   
@@ -228,10 +232,10 @@ const char *dvr_entry_status(dvr_entry_t *de);
 
 const char *dvr_entry_schedstatus(dvr_entry_t *de);
 
-void dvr_entry_create_by_autorec(event_t *e, dvr_autorec_entry_t *dae);
+void dvr_entry_create_by_autorec(epg_broadcast_t *e, dvr_autorec_entry_t *dae);
 
 dvr_entry_t *dvr_entry_create_by_event(const char *dvr_config_name,
-                                       event_t *e, const char *creator,
+                                       epg_broadcast_t *e, const char *creator,
 				       dvr_autorec_entry_t *dae,
 				       dvr_prio_t pri);
 
@@ -239,7 +243,6 @@ dvr_entry_t *dvr_entry_create(const char *dvr_config_name,
                               channel_t *ch, time_t start, time_t stop, 
 			      const char *title, const char *description,
 			      const char *creator, dvr_autorec_entry_t *dae,
-			      epg_episode_t *ee, uint8_t content_type,
 			      dvr_prio_t pri);
 
 dvr_entry_t *dvr_entry_update(dvr_entry_t *de, const char* de_title, int de_start, int de_stop);
@@ -254,13 +257,13 @@ void dvr_rec_subscribe(dvr_entry_t *de);
 
 void dvr_rec_unsubscribe(dvr_entry_t *de, int stopcode);
 
-void dvr_event_replaced(event_t *e, event_t *new_e);
+void dvr_event_replaced(epg_broadcast_t *e, epg_broadcast_t *new_e);
 
 dvr_entry_t *dvr_entry_find_by_id(int id);
 
-dvr_entry_t *dvr_entry_find_by_event(event_t *e);
+dvr_entry_t *dvr_entry_find_by_event(epg_broadcast_t *e);
 
-dvr_entry_t *dvr_entry_find_by_event_fuzzy(event_t *e);
+dvr_entry_t *dvr_entry_find_by_event_fuzzy(epg_broadcast_t *e);
 
 off_t dvr_get_filesize(dvr_entry_t *de);
 
@@ -305,7 +308,7 @@ void dvr_autorec_add(const char *dvr_config_name,
 		     const char *tag, uint8_t content_type,
 		     const char *creator, const char *comment);
 
-void dvr_autorec_check_event(event_t *e);
+void dvr_autorec_check_event(epg_broadcast_t *e);
 
 void autorec_destroy_by_channel(channel_t *ch);
 
diff --git a/src/dvr/dvr_autorec.c b/src/dvr/dvr_autorec.c
index 19d76576..549b2637 100644
--- a/src/dvr/dvr_autorec.c
+++ b/src/dvr/dvr_autorec.c
@@ -62,10 +62,11 @@ dvr_autorec_purge_spawns(dvr_autorec_entry_t *dae)
  * return 1 if the event 'e' is matched by the autorec rule 'dae'
  */
 static int
-autorec_cmp(dvr_autorec_entry_t *dae, event_t *e)
+autorec_cmp(dvr_autorec_entry_t *dae, epg_broadcast_t *e)
 {
   channel_tag_mapping_t *ctm;
 
+  if (!e->channel || !e->channel->channel) return 0;
   if(dae->dae_enabled == 0 || dae->dae_weekdays == 0)
     return 0;
 
@@ -76,33 +77,34 @@ autorec_cmp(dvr_autorec_entry_t *dae, event_t *e)
     return 0; // Avoid super wildcard match
 
   if(dae->dae_channel != NULL &&
-     dae->dae_channel != e->e_channel)
+     dae->dae_channel != e->channel->channel)
     return 0;
   
   if(dae->dae_channel_tag != NULL) {
     LIST_FOREACH(ctm, &dae->dae_channel_tag->ct_ctms, ctm_tag_link)
-      if(ctm->ctm_channel == e->e_channel)
+      if(ctm->ctm_channel == e->channel->channel)
 	break;
     if(ctm == NULL)
       return 0;
   }
 
-
+#if TODO_GENRE_SUPPORT
   if(dae->dae_content_type != 0 &&
      dae->dae_content_type != e->e_content_type)
     return 0;
+#endif
   
   if(dae->dae_title != NULL) {
-    if(e->e_title == NULL ||
-       regexec(&dae->dae_title_preg, e->e_title, 0, NULL, 0))
+    if(e->episode->title == NULL ||
+       regexec(&dae->dae_title_preg, e->episode->title, 0, NULL, 0))
     return 0;
   }
 
   if(dae->dae_approx_time != 0) {
     struct tm a_time;
     struct tm ev_time;
-    localtime_r(&e->e_start, &a_time);
-    localtime_r(&e->e_start, &ev_time);
+    localtime_r(&e->start, &a_time);
+    localtime_r(&e->start, &ev_time);
     a_time.tm_min = dae->dae_approx_time % 60;
     a_time.tm_hour = dae->dae_approx_time / 60;
     if(abs(mktime(&a_time) - mktime(&ev_time)) > 900)
@@ -111,7 +113,7 @@ autorec_cmp(dvr_autorec_entry_t *dae, event_t *e)
 
   if(dae->dae_weekdays != 0x7f) {
     struct tm tm;
-    localtime_r(&e->e_start, &tm);
+    localtime_r(&e->start, &tm);
     if(!((1 << ((tm.tm_wday ?: 7) - 1)) & dae->dae_weekdays))
       return 0;
   }
@@ -489,7 +491,7 @@ dvr_autorec_add(const char *config_name,
  *
  */
 void
-dvr_autorec_check_event(event_t *e)
+dvr_autorec_check_event(epg_broadcast_t *e)
 {
   dvr_autorec_entry_t *dae;
   dvr_entry_t *existingde;
@@ -498,8 +500,8 @@ dvr_autorec_check_event(event_t *e)
     if(autorec_cmp(dae, e)) {
       existingde = dvr_entry_find_by_event_fuzzy(e);
       if (existingde != NULL) {
-        tvhlog(LOG_DEBUG, "dvr", "Updating existing DVR entry for %s", e->e_title);
-        dvr_entry_update(existingde, e->e_title, e->e_start, e->e_stop);
+        tvhlog(LOG_DEBUG, "dvr", "Updating existing DVR entry for %s", e->episode->title);
+        dvr_entry_update(existingde, e->episode->title, e->start, e->stop);
       } else
         dvr_entry_create_by_autorec(e, dae);
     }
@@ -511,7 +513,7 @@ dvr_autorec_check_event(event_t *e)
 static void
 dvr_autorec_changed(dvr_autorec_entry_t *dae)
 {
-#if TODO_DVR
+#if TODO_DVR_AUTOREC
   channel_t *ch;
   event_t *e;
 
diff --git a/src/dvr/dvr_db.c b/src/dvr/dvr_db.c
index 76fc3bc1..d3e26163 100644
--- a/src/dvr/dvr_db.c
+++ b/src/dvr/dvr_db.c
@@ -30,7 +30,7 @@
 #include "htsp.h"
 #include "streaming.h"
 
-//static int de_tally;
+static int de_tally;
 
 int dvr_iov_max;
 
@@ -40,9 +40,7 @@ struct dvr_entry_list dvrentries;
 static void dvr_entry_save(dvr_entry_t *de);
 
 static void dvr_timer_expire(void *aux);
-#if 0
 static void dvr_timer_start_recording(void *aux);
-#endif
 
 /**
  * Return printable status for a dvr entry
@@ -155,7 +153,6 @@ dvr_entry_notify(dvr_entry_t *de)
 /**
  *
  */
-#if TODO
 static void
 dvr_make_title(char *output, size_t outlen, dvr_entry_t *de)
 {
@@ -185,16 +182,11 @@ dvr_make_title(char *output, size_t outlen, dvr_entry_t *de)
   }
 
   if(cfg->dvr_flags & DVR_EPISODE_IN_TITLE) {
-
-    if(de->de_episode.ee_season && de->de_episode.ee_episode)
-      snprintf(output + strlen(output), outlen - strlen(output), 
-	       ".S%02dE%02d",
-	       de->de_episode.ee_season, de->de_episode.ee_episode);
-
-    else if(de->de_episode.ee_episode)
-      snprintf(output + strlen(output), outlen - strlen(output), 
-	       ".E%02d",
-	       de->de_episode.ee_episode);
+    if(de->de_bcast)  
+      epg_episode_number_format(de->de_bcast->episode,
+                                output + strlen(output),
+                                outlen - strlen(output),
+                                ".", "S%02d", NULL, "E%02d", NULL);
   }
 
   if(cfg->dvr_flags & DVR_CLEAN_TITLE) {
@@ -210,13 +202,10 @@ dvr_make_title(char *output, size_t outlen, dvr_entry_t *de)
         }
   }
 }
-#endif
-
 
 /**
  *
  */
-#if TODO
 static void
 dvr_entry_link(dvr_entry_t *de)
 {
@@ -251,20 +240,17 @@ dvr_entry_link(dvr_entry_t *de)
   }
   htsp_dvr_entry_add(de);
 }
-#endif
-
 
 /**
- *
+ * Create the event
  */
-dvr_entry_t *
-dvr_entry_create(const char *config_name,
-                 channel_t *ch, time_t start, time_t stop, 
-		 const char *title, const char *description,
-		 const char *creator, dvr_autorec_entry_t *dae,
-		 epg_episode_t *ee, uint8_t content_type, dvr_prio_t pri)
+static dvr_entry_t *_dvr_entry_create (
+  const char *config_name, epg_broadcast_t *e,
+  channel_t *ch, time_t start, time_t stop, 
+	const char *title, const char *description,
+	const char *creator, dvr_autorec_entry_t *dae,
+	dvr_prio_t pri)
 {
-#if TODO
   dvr_entry_t *de;
   char tbuf[30];
   struct tm tm;
@@ -297,14 +283,9 @@ dvr_entry_create(const char *config_name,
   de->de_title   = strdup(title);
   de->de_desc    = description ? strdup(description) : NULL;
 
-  if(ee != NULL) {
-    de->de_episode.ee_season  = ee->ee_season;
-    de->de_episode.ee_episode = ee->ee_episode;
-    de->de_episode.ee_part    = ee->ee_part;
-    tvh_str_set(&de->de_episode.ee_onscreen, ee->ee_onscreen);
-  }
-
+#if TODO_GENRE_SUPPORT
   de->de_content_type = content_type;
+#endif
 
   dvr_entry_link(de);
 
@@ -324,52 +305,40 @@ dvr_entry_create(const char *config_name,
   dvrdb_changed();
   dvr_entry_save(de);
   return de;
-#endif
-  return NULL;
 }
 
 
-/**
- *
- */
-#if TODO
-static const char *
-longest_string(const char *a, const char *b)
-{
-  if(b == NULL)
-    return a;
-  if(a == NULL)
-    return b;
-  return strlen(a) > strlen(b) ? a : b;
-}
-#endif
-
-
 /**
  *
  */
 dvr_entry_t *
-dvr_entry_create_by_event(const char *config_name,
-                          event_t *e, const char *creator, 
-			  dvr_autorec_entry_t *dae, dvr_prio_t pri)
+dvr_entry_create(const char *config_name,
+                 channel_t *ch, time_t start, time_t stop, 
+		 const char *title, const char *description,
+		 const char *creator, dvr_autorec_entry_t *dae, dvr_prio_t pri)
 {
-#if TODO
-  const char *desc = NULL;
-  if(e->e_channel == NULL || e->e_title == NULL)
+  return _dvr_entry_create(config_name, NULL,
+                           ch, start, stop, title, description,
+                           creator, dae, pri);
+}
+
+/**
+ *
+ */
+dvr_entry_t *
+dvr_entry_create_by_event(const char *config_name,
+                          epg_broadcast_t *e, const char *creator, 
+                          dvr_autorec_entry_t *dae, dvr_prio_t pri)
+{
+  if(e->channel == NULL || e->channel->channel || e->episode->title == NULL)
     return NULL;
 
-  // Try to find best description
-
-  desc = longest_string(e->e_desc, e->e_ext_desc);
-  desc = longest_string(desc, e->e_ext_item);
-  desc = longest_string(desc, e->e_ext_text);
-
-  return dvr_entry_create(config_name,
-                          e->e_channel, e->e_start, e->e_stop, 
-			  e->e_title, desc, creator, dae, &e->e_episode,
-			  e->e_content_type, pri);
-#endif
-  return NULL;
+  return _dvr_entry_create(config_name, e,
+                           e->channel->channel, e->start, e->stop,
+                           e->episode->title,
+                           e->episode->description ? e->episode->description
+                                                   : e->episode->summary,
+                           creator, dae, pri);
 }
 
 
@@ -377,7 +346,7 @@ dvr_entry_create_by_event(const char *config_name,
  *
  */
 void
-dvr_entry_create_by_autorec(event_t *e, dvr_autorec_entry_t *dae)
+dvr_entry_create_by_autorec(epg_broadcast_t *e, dvr_autorec_entry_t *dae)
 {
   char buf[200];
 
@@ -396,7 +365,6 @@ dvr_entry_create_by_autorec(event_t *e, dvr_autorec_entry_t *dae)
 void
 dvr_entry_dec_ref(dvr_entry_t *de)
 {
-#if TODO
   lock_assert(&global_lock);
 
   if(de->de_refcnt > 1) {
@@ -413,10 +381,7 @@ dvr_entry_dec_ref(dvr_entry_t *de)
   free(de->de_ititle);
   free(de->de_desc);
 
-  free(de->de_episode.ee_onscreen);
-
   free(de);
-#endif
 }
 
 
@@ -653,19 +618,24 @@ dvr_entry_update(dvr_entry_t *de, const char* de_title, int de_start, int de_sto
 
 /**
  * Used to notify the DVR that an event has been replaced in the EPG
+ *
+ * TODO: I think this will record the title slot event if its now a 
+ *       completely different episode etc...
  */
 void 
-dvr_event_replaced(event_t *e, event_t *new_e)
+dvr_event_replaced(epg_broadcast_t *e, epg_broadcast_t *new_e)
 {
   dvr_entry_t *de, *ude;
+  if ( e == new_e ) return;
 
   de = dvr_entry_find_by_event(e);
   if (de != NULL) {
     ude = dvr_entry_find_by_event_fuzzy(new_e);
     if (ude == NULL && de->de_sched_state == DVR_SCHEDULED)
       dvr_entry_cancel(de);
-    else if(new_e->e_title != NULL)
-      dvr_entry_update(de, new_e->e_title, new_e->e_start, new_e->e_stop);
+    else if(new_e->episode->title != NULL)
+      dvr_entry_update(de, new_e->episode->title, new_e->start, new_e->stop);
+      // TODO: need to actually replace the event?
   }
       
     
@@ -701,20 +671,17 @@ dvr_stop_recording(dvr_entry_t *de, int stopcode)
 /**
  *
  */
-#if TODO
 static void
 dvr_timer_stop_recording(void *aux)
 {
   dvr_stop_recording(aux, 0);
 }
-#endif
 
 
 
 /**
  *
  */
-#if 0
 static void
 dvr_timer_start_recording(void *aux)
 {
@@ -733,7 +700,6 @@ dvr_timer_start_recording(void *aux)
   gtimer_arm_abs(&de->de_timer, dvr_timer_stop_recording, de, 
 		 de->de_stop + (60 * de->de_stop_extra));
 }
-#endif
 
 
 /**
@@ -754,14 +720,12 @@ dvr_entry_find_by_id(int id)
  *
  */
 dvr_entry_t *
-dvr_entry_find_by_event(event_t *e)
+dvr_entry_find_by_event(epg_broadcast_t *e)
 {
   dvr_entry_t *de;
 
-  LIST_FOREACH(de, &e->e_channel->ch_dvrs, de_channel_link)
-    if(de->de_start == e->e_start &&
-       de->de_stop  == e->e_stop)
-      return de;
+  LIST_FOREACH(de, &e->channel->channel->ch_dvrs, de_channel_link)
+    if(de->de_bcast == e) return de;
   return NULL;
 }
 
@@ -769,15 +733,15 @@ dvr_entry_find_by_event(event_t *e)
  * Find dvr entry using 'fuzzy' search
  */
 dvr_entry_t *
-dvr_entry_find_by_event_fuzzy(event_t *e)
+dvr_entry_find_by_event_fuzzy(epg_broadcast_t *e)
 {
   dvr_entry_t *de;
   
-  if (e->e_title == NULL)
+  if (e->episode->title == NULL)
     return NULL;
 
-  LIST_FOREACH(de, &e->e_channel->ch_dvrs, de_channel_link)
-    if ((abs(de->de_start - e->e_start) < 600) && (abs(de->de_stop - e->e_stop) < 600)) {
+  LIST_FOREACH(de, &e->channel->channel->ch_dvrs, de_channel_link)
+    if ((abs(de->de_start - e->start) < 600) && (abs(de->de_stop - e->stop) < 600)) {
         return de;
     }
   return NULL;
diff --git a/src/dvr/mkmux.c b/src/dvr/mkmux.c
index 446eff3d..851f45f6 100644
--- a/src/dvr/mkmux.c
+++ b/src/dvr/mkmux.c
@@ -441,6 +441,7 @@ build_tag_string(const char *name, const char *value,
 /**
  *
  */
+#if TODO_EP_NUMBER
 static htsbuf_queue_t *
 build_tag_int(const char *name, int value,
 	      int targettype, const char *targettypename)
@@ -449,6 +450,7 @@ build_tag_int(const char *name, int value,
   snprintf(str, sizeof(str), "%d", value);
   return build_tag_string(name, str, targettype, targettypename);
 }
+#endif
 
 
 /**
@@ -470,7 +472,7 @@ mk_build_metadata(const dvr_entry_t *de)
   htsbuf_queue_t *q = htsbuf_queue_alloc(0);
   char datestr[64];
   struct tm tm;
-#if TODO
+#if TODO_GENRE_SUPPORT
   const char *ctype;
 #endif
   localtime_r(&de->de_start, &tm);
@@ -489,7 +491,7 @@ mk_build_metadata(const dvr_entry_t *de)
   addtag(q, build_tag_string("ORIGINAL_MEDIA_TYPE", "TV", 0, NULL));
 
   
-#if TODO
+#if TODO_GENRE_SUPPORT
   if(de->de_content_type) {
     ctype = epg_content_group_get_name(de->de_content_type);
     if(ctype != NULL)
@@ -500,7 +502,7 @@ mk_build_metadata(const dvr_entry_t *de)
   if(de->de_channel != NULL)
     addtag(q, build_tag_string("TVCHANNEL", de->de_channel->ch_name, 0, NULL));
 
-#if TODO
+#if TODO_EP_NUMBER
   if(de->de_episode.ee_onscreen)
     addtag(q, build_tag_string("SYNOPSIS", 
 			       de->de_episode.ee_onscreen, 0, NULL));
@@ -509,7 +511,7 @@ mk_build_metadata(const dvr_entry_t *de)
   if(de->de_desc != NULL)
     addtag(q, build_tag_string("SUMMARY", de->de_desc, 0, NULL));
 
-#if TODO
+#if TODO_EP_NUMBER
   if(de->de_episode.ee_season)
     addtag(q, build_tag_int("PART_NUMBER", de->de_episode.ee_season,
 			    60, "SEASON"));
@@ -528,15 +530,16 @@ mk_build_metadata(const dvr_entry_t *de)
 
 
 static htsbuf_queue_t *
-mk_build_metadata2(const event_t *e)
+mk_build_metadata2(const epg_broadcast_t *e)
 {
   htsbuf_queue_t *q = htsbuf_queue_alloc(0);
+  epg_episode_t *ee = e->episode;
   char datestr[64];
   struct tm tm;
-#if TODO
+#if TODO_GENRE_SUPPORT
   const char *ctype;
 #endif
-  localtime_r(&e->e_start, &tm);
+  localtime_r(&e->start, &tm);
 
   snprintf(datestr, sizeof(datestr),
 	   "%04d-%02d-%02d %02d:%02d:%02d",
@@ -552,7 +555,7 @@ mk_build_metadata2(const event_t *e)
   addtag(q, build_tag_string("ORIGINAL_MEDIA_TYPE", "TV", 0, NULL));
 
   
-#if TODO
+#if TODO_GENRE_SUPPORT
   if(e->e_content_type) {
     ctype = epg_content_group_get_name(e->e_content_type);
     if(ctype != NULL)
@@ -560,19 +563,22 @@ mk_build_metadata2(const event_t *e)
   }
 #endif
 
-  if(e->e_channel != NULL)
-    addtag(q, build_tag_string("TVCHANNEL", e->e_channel->ch_name, 0, NULL));
+  if(e->channel->channel != NULL)
+    addtag(q, build_tag_string("TVCHANNEL", e->channel->channel->ch_name, 0, NULL));
 
-  if(e->e_title != NULL)
-    addtag(q, build_tag_string("TITLE", e->e_title, 0, NULL));
+  if(ee->title != NULL)
+    addtag(q, build_tag_string("TITLE", ee->title, 0, NULL));
 
+  if(ee->description)
+    addtag(q, build_tag_string("SUMMARY", ee->description, 0, NULL));
+  else if(ee->summary)
+    addtag(q, build_tag_string("SUMMARY", ee->summary, 0, NULL));
+
+#if TODO_EP_NUMBER
   if(e->e_episode.ee_onscreen)
     addtag(q, build_tag_string("SYNOPSIS", 
 			       e->e_episode.ee_onscreen, 0, NULL));
 
-  if(e->e_desc != NULL)
-    addtag(q, build_tag_string("SUMMARY", e->e_desc, 0, NULL));
-
   if(e->e_episode.ee_season)
     addtag(q, build_tag_int("PART_NUMBER", e->e_episode.ee_season,
 			    60, "SEASON"));
@@ -584,6 +590,7 @@ mk_build_metadata2(const event_t *e)
   if(e->e_episode.ee_part)
     addtag(q, build_tag_int("PART_NUMBER", e->e_episode.ee_part,
 			    40, "PART"));
+#endif
 
   return q;
 }
@@ -796,7 +803,7 @@ mk_close_cluster(mk_mux_t *mkm)
  *
  */
 int
-mk_mux_append_meta(mk_mux_t *mkm, event_t *e)
+mk_mux_append_meta(mk_mux_t *mkm, epg_broadcast_t *e)
 {
   htsbuf_queue_t q;
 
diff --git a/src/dvr/mkmux.h b/src/dvr/mkmux.h
index f0304351..8e0c5912 100644
--- a/src/dvr/mkmux.h
+++ b/src/dvr/mkmux.h
@@ -38,7 +38,7 @@ mk_mux_t *mk_mux_stream_create(int fd,
 
 int mk_mux_write_pkt(mk_mux_t *mkm, struct th_pkt *pkt);
 
-int mk_mux_append_meta(mk_mux_t *mkm, struct event *e);
+int mk_mux_append_meta(mk_mux_t *mkm, struct epg_broadcast *e);
 
 void mk_mux_close(mk_mux_t *mk_mux);
 
diff --git a/src/epg.c b/src/epg.c
index df519c18..e2a6bd14 100644
--- a/src/epg.c
+++ b/src/epg.c
@@ -815,17 +815,26 @@ static void _epg_episode_rem_broadcast
   RB_REMOVE(&episode->broadcasts, broadcast, elink);
 }
 
-int epg_episode_get_number_onscreen
-  ( epg_episode_t *episode, char *buf, int len )
+
+size_t epg_episode_number_format 
+  ( epg_episode_t *episode, char *buf, size_t len,
+    const char *pre,  const char *sfmt,
+    const char *sep,  const char *efmt,
+    const char *cfmt )
 {
-  int i = 0;
+  size_t i = 0;
   if ( episode->number ) {
-    // TODO: add counts
-    if ( episode->season && episode->season->number ) {
-      i += snprintf(&buf[i], len-i, "Season %d ",
-                    episode->season->number);
+    if (pre) i += snprintf(&buf[i], len-i, "%s", pre);
+    if ( sfmt && episode->season && episode->season->number ) {
+      i += snprintf(&buf[i], len-i, sfmt, episode->season->number);
+      if ( cfmt && episode->brand && episode->brand->season_count )
+        i += snprintf(&buf[i], len-i, cfmt,
+                      episode->brand->season_count);
+      if (sep) i += snprintf(&buf[i], len-i, "%s", sep);
     }
-    i += snprintf(&buf[i], len-i, "Episode %d", episode->number);
+    i += snprintf(&buf[i], len-i, efmt, episode->number);
+    if ( cfmt && episode->season && episode->season->episode_count)
+      i+= snprintf(&buf[i], len-i, cfmt, episode->season->episode_count);
   }
   return i;
 }
diff --git a/src/epg.h b/src/epg.h
index a68acc60..0137852d 100644
--- a/src/epg.h
+++ b/src/epg.h
@@ -200,8 +200,21 @@ int epg_episode_set_brand        ( epg_episode_t *e, epg_brand_t *b )
 int epg_episode_set_season       ( epg_episode_t *e, epg_season_t *s )
   __attribute__((warn_unused_result));
 
-/* Acessors */
-int epg_episode_get_number_onscreen ( epg_episode_t *e, char *b, int c );
+/* EpNum format helper */
+// output string will be:
+// if (episode_num) 
+//   ret = pre
+//   if (season_num) ret += sprintf(sfmt, season_num)
+//   if (season_cnt && cnt) ret += sprintf(cnt, season_cnt)
+//   ret += sep
+//   ret += sprintf(efmt, episode_num)
+//   if (episode_cnt) ret += sprintf(cfmt, episode_cnt)
+// and will return num chars written
+size_t epg_episode_number_format 
+  ( epg_episode_t *e, char *buf, size_t len,
+    const char *pre,  const char *sfmt,
+    const char *sep,  const char *efmt,
+    const char *cfmt );
 
 /* Serialization */
 htsmsg_t      *epg_episode_serialize   ( epg_episode_t *b );
@@ -342,7 +355,8 @@ void epg_updated (void);
  * Compatibility code
  * ***********************************************************************/
 
-#ifndef TODO_REMOVE_EPG_COMPAT 
+//#define TODO_EPG_COMPAT
+#ifdef TODO_EPG_COMPAT
 
 typedef struct _epg_episode {
 
diff --git a/src/tvheadend.h b/src/tvheadend.h
index a82feaee..91211deb 100644
--- a/src/tvheadend.h
+++ b/src/tvheadend.h
@@ -104,8 +104,6 @@ LIST_HEAD(th_subscription_list, th_subscription);
 RB_HEAD(channel_tree, channel);
 TAILQ_HEAD(channel_queue, channel);
 LIST_HEAD(channel_list, channel);
-LIST_HEAD(event_list, event);
-RB_HEAD(event_tree, event);
 LIST_HEAD(dvr_config_list, dvr_config);
 LIST_HEAD(dvr_entry_list, dvr_entry);
 TAILQ_HEAD(ref_update_queue, ref_update);
diff --git a/src/webui/extjs.c b/src/webui/extjs.c
index f1b07f03..7e87d59f 100644
--- a/src/webui/extjs.c
+++ b/src/webui/extjs.c
@@ -728,19 +728,8 @@ extjs_epg(http_connection_t *hc, const char *remain, void *opaque)
     else if(ee->summary != NULL)
       htsmsg_add_str(m, "description", ee->summary);
 
-    if (epg_episode_get_number_onscreen(ee, buf, 100))
-      htsmsg_add_str(m, "episode", strdup(buf));
-
-#if TODO_REMOVE_THIS_QQ
-    if(e->e_ext_desc != NULL)
-      htsmsg_add_str(m, "ext_desc", e->e_ext_desc);
-
-    if(e->e_ext_item != NULL)
-      htsmsg_add_str(m, "ext_item", e->e_ext_item);
-
-    if(e->e_ext_text != NULL)
-      htsmsg_add_str(m, "ext_text", e->e_ext_text);
-#endif
+    if (epg_episode_number_format(ee, buf, 100, NULL, "Season %d", ".", "Episode %d", "/%d"))
+      htsmsg_add_str(m, "episode", buf);
 
     htsmsg_add_u32(m, "id", e->_.id);
     htsmsg_add_u32(m, "start", e->start);
@@ -752,11 +741,9 @@ extjs_epg(http_connection_t *hc, const char *remain, void *opaque)
       htsmsg_add_str(m, "contentgrp", s);
 #endif
 
-#if TODO_UPDATE_DVR_CODE
     dvr_entry_t *de;
     if((de = dvr_entry_find_by_event(e)) != NULL)
       htsmsg_add_str(m, "schedstate", dvr_entry_schedstatus(de));
-#endif
 
     htsmsg_add_msg(array, NULL, m);
   }
@@ -824,8 +811,8 @@ extjs_epgrelated(http_connection_t *hc, const char *remain, void *opaque)
             htsmsg_add_str(m, "uri", ee2->_.uri);
             htsmsg_add_str(m, "title", ee2->title);
             if (ee2->subtitle) htsmsg_add_str(m, "title", ee2->subtitle);
-            if (epg_episode_get_number_onscreen(ee2, buf, 100))
-              htsmsg_add_str(m, "episode", strdup(buf));
+            if (epg_episode_number_format(ee, buf, 100, NULL, "Season %d", ".", "Episode %d", "/%d"))
+              htsmsg_add_str(m, "episode", buf);
             htsmsg_add_msg(array, NULL, m);
           }
         } else if (ee->season) {
@@ -837,8 +824,8 @@ extjs_epgrelated(http_connection_t *hc, const char *remain, void *opaque)
             htsmsg_add_str(m, "uri", ee2->_.uri);
             htsmsg_add_str(m, "title", ee2->title);
             if (ee2->subtitle) htsmsg_add_str(m, "title", ee2->subtitle);
-            if (epg_episode_get_number_onscreen(ee2, buf, 100))
-              htsmsg_add_str(m, "episode", strdup(buf));
+            if (epg_episode_number_format(ee, buf, 100, NULL, "Season %d", ".", "Episode %d", "/%d"))
+              htsmsg_add_str(m, "episode", buf);
             htsmsg_add_msg(array, NULL, m);
           }
         }
@@ -864,11 +851,11 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
   htsbuf_queue_t *hq = &hc->hc_reply;
   const char *op = http_arg_get(&hc->hc_req_args, "op");
   htsmsg_t *out, *r;
-  //TODO:event_t *e;
   dvr_entry_t *de;
   const char *s;
   int flags = 0;
   dvr_config_t *cfg;
+  epg_broadcast_t *e;
 
   if(op == NULL)
     op = "loadSettings";
@@ -882,11 +869,10 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
 
   if(!strcmp(op, "recordEvent")) {
 
-#if TODO_DVR
     const char *config_name = http_arg_get(&hc->hc_req_args, "config_name");
 
     s = http_arg_get(&hc->hc_req_args, "eventId");
-    if((e = epg_event_find_by_id(atoi(s))) == NULL) {
+    if((e = epg_broadcast_find_by_id(atoi(s), NULL)) == NULL) {
       pthread_mutex_unlock(&global_lock);
       return HTTP_STATUS_BAD_REQUEST;
     }
@@ -906,7 +892,6 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
 
     dvr_entry_create_by_event(config_name,
                               e, hc->hc_representative, NULL, DVR_PRIO_NORMAL);
-#endif
 
     out = htsmsg_create_map();
     htsmsg_add_u32(out, "success", 1);
@@ -990,13 +975,13 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
 
     dvr_entry_create(config_name,
                      ch, start, stop, title, NULL, hc->hc_representative, 
-		     NULL, NULL, 0, dvr_pri2val(pri));
+		                 NULL, dvr_pri2val(pri));
 
     out = htsmsg_create_map();
     htsmsg_add_u32(out, "success", 1);
 
   } else if(!strcmp(op, "createAutoRec")) {
-#if TODO_DVR
+#if TODO_DVR_AUTOREC
     const char *cgrp = http_arg_get(&hc->hc_req_args, "contentgrp");
 
     
diff --git a/src/webui/simpleui.c b/src/webui/simpleui.c
index d43eadaa..7733becc 100644
--- a/src/webui/simpleui.c
+++ b/src/webui/simpleui.c
@@ -209,7 +209,6 @@ page_einfo(http_connection_t *hc, const char *remain, void *opaque)
     return 404;
   }
 
-#if TODO_DVR
   de = dvr_entry_find_by_event(e);
 
   if((http_arg_get(&hc->hc_req_args, "rec")) != NULL) {
@@ -218,7 +217,6 @@ page_einfo(http_connection_t *hc, const char *remain, void *opaque)
   } else if(de != NULL && (http_arg_get(&hc->hc_req_args, "cancel")) != NULL) {
     de = dvr_entry_cancel(de);
   }
-#endif
 
   htsbuf_qprintf(hq, "<html>");
   htsbuf_qprintf(hq, "<body>");