Updated EPG methods to include source epggrab_module to ensure priorities are properl...

diff --git a/src/epg.c b/src/epg.c
index a62426910bb3b9004411fc21b84fdcf639ce8844..355836931708979bc0f15a172f823dd689b6502c 100644 (file)
--- a/src/epg.c
+++ b/src/epg.c
@@ -1,6 +1,6 @@
 /*
  *  Electronic Program Guide - Common functions
- *  Copyright (C) 2007 Andreas Öman
+ *  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
@@ -229,12 +229,23 @@ static epg_object_t *_epg_object_deserialize ( htsmsg_t *m, epg_object_t *eo )
   return eo;
 }
 
+static int _epg_object_set_grabber ( void *o, epggrab_module_t *grab  )
+{
+  epg_object_t *eo = o;
+  if ( !grab ) return 1; // grab=NULL is override
+  if ( eo->grabber != grab && grab->priority > eo->grabber->priority ) {
+    eo->grabber = grab;
+  }
+  return grab == eo->grabber;
+}
+
 static int _epg_object_set_str
-  ( void *o, char **old, const char *new )
+  ( void *o, char **old, const char *new, epggrab_module_t *src )
 {
-  epg_object_t *eo = (epg_object_t*)o;
   int save = 0;
+  epg_object_t *eo = (epg_object_t*)o;
   if ( !eo || !new ) return 0;
+  if ( !_epg_object_set_grabber(eo, src) && *old ) return 0;
   if ( !*old || strcmp(*old, new) ) {
     if ( *old ) free(*old);
     *old = strdup(new);
@@ -245,9 +256,10 @@ static int _epg_object_set_str
 }
 
 static int _epg_object_set_u8
-  ( void *o, uint8_t *old, const uint8_t new )
+  ( void *o, uint8_t *old, const uint8_t new, epggrab_module_t *src )
 {
   int save = 0;
+  if ( !_epg_object_set_grabber(o, src) && *old ) return 0;
   if ( *old != new ) {
     *old = new;
     _epg_object_set_updated(o);
@@ -257,9 +269,10 @@ static int _epg_object_set_u8
 }
 
 static int _epg_object_set_u16
-  ( void *o, uint16_t *old, const uint16_t new )
+  ( void *o, uint16_t *old, const uint16_t new, epggrab_module_t *src )
 {
   int save = 0;
+  if ( !_epg_object_set_grabber(o, src) && *old ) return 0;
   if ( *old != new ) {
     *old = new;
     _epg_object_set_updated(o);
@@ -268,17 +281,6 @@ static int _epg_object_set_u16
   return save;
 }
 
-static int _epg_object_set_grabber 
-  ( void *o, epggrab_module_t *grab, int *save )
-{
-  epg_object_t *eo = o;
-  if ( eo->grabber != grab && grab->priority > eo->grabber->priority ) {
-    eo->grabber = grab;
-    *save       = 1;
-  }
-  return grab == eo->grabber;
-}
-
 /* **************************************************************************
  * Brand
  * *************************************************************************/
@@ -332,35 +334,32 @@ epg_brand_t *epg_brand_find_by_id ( uint64_t id )
   return (epg_brand_t*)_epg_object_find_by_id(id, EPG_BRAND);
 }
 
-int epg_brand_set_title ( epg_brand_t *brand, const char *title )
+int epg_brand_set_title
+  ( epg_brand_t *brand, const char *title, epggrab_module_t *src )
 {
   if (!brand || !title) return 0;
-  return _epg_object_set_str(brand, &brand->title, title);
+  return _epg_object_set_str(brand, &brand->title, title, src);
 }
 
-int epg_brand_set_summary ( epg_brand_t *brand, const char *summary )
+int epg_brand_set_summary
+  ( epg_brand_t *brand, const char *summary, epggrab_module_t *src )
 {
   if (!brand || !summary) return 0;
-  return _epg_object_set_str(brand, &brand->summary, summary);
+  return _epg_object_set_str(brand, &brand->summary, summary, src);
 }
 
-int epg_brand_set_image ( epg_brand_t *brand, const char *image )
+int epg_brand_set_image
+  ( epg_brand_t *brand, const char *image, epggrab_module_t *src )
 {
   if (!brand || !image) return 0;
-  return _epg_object_set_str(brand, &brand->image, image);
+  return _epg_object_set_str(brand, &brand->image, image, src);
 }
 
-int epg_brand_set_season_count ( epg_brand_t *brand, uint16_t count )
+int epg_brand_set_season_count
+  ( epg_brand_t *brand, uint16_t count, epggrab_module_t *src )
 {
   if (!brand || !count) return 0;
-  return _epg_object_set_u16(brand, &brand->season_count, count);
-}
-
-int epg_brand_set_grabber 
-  ( epg_brand_t *brand, epggrab_module_t *grab, int *save )
-{
-  if (!brand || !grab) return 0;
-  return _epg_object_set_grabber(brand, grab, save);
+  return _epg_object_set_u16(brand, &brand->season_count, count, src);
 }
 
 static void _epg_brand_add_season 
@@ -420,11 +419,11 @@ epg_brand_t *epg_brand_deserialize ( htsmsg_t *m, int create, int *save )
   if ( !(eb = epg_brand_find_by_uri((*skel)->uri, create, save)) ) return NULL;
   
   if ( (str = htsmsg_get_str(m, "title")) )
-    *save |= epg_brand_set_title(eb, str);
+    *save |= epg_brand_set_title(eb, str, NULL);
   if ( (str = htsmsg_get_str(m, "summary")) )
-    *save |= epg_brand_set_summary(eb, str);
+    *save |= epg_brand_set_summary(eb, str, NULL);
   if ( !htsmsg_get_u32(m, "season-count", &u32) )
-    *save |= epg_brand_set_season_count(eb, u32);
+    *save |= epg_brand_set_season_count(eb, u32, NULL);
 
   return eb;
 }
@@ -491,34 +490,40 @@ epg_season_t *epg_season_find_by_id ( uint64_t id )
   return (epg_season_t*)_epg_object_find_by_id(id, EPG_SEASON);
 }
 
-int epg_season_set_summary ( epg_season_t *season, const char *summary )
+int epg_season_set_summary
+  ( epg_season_t *season, const char *summary, epggrab_module_t *src )
 {
   if (!season || !summary) return 0;
-  return _epg_object_set_str(season, &season->summary, summary);
+  return _epg_object_set_str(season, &season->summary, summary, src);
 }
 
-int epg_season_set_image ( epg_season_t *season, const char *image )
+int epg_season_set_image
+  ( epg_season_t *season, const char *image, epggrab_module_t *src )
 {
   if (!season || !image) return 0;
-  return _epg_object_set_str(season, &season->image, image);
+  return _epg_object_set_str(season, &season->image, image, src);
 }
 
-int epg_season_set_episode_count ( epg_season_t *season, uint16_t count )
+int epg_season_set_episode_count
+  ( epg_season_t *season, uint16_t count, epggrab_module_t *src )
 {
   if (!season || !count) return 0;
-  return _epg_object_set_u16(season, &season->episode_count, count);
+  return _epg_object_set_u16(season, &season->episode_count, count, src);
 }
 
-int epg_season_set_number ( epg_season_t *season, uint16_t number )
+int epg_season_set_number
+  ( epg_season_t *season, uint16_t number, epggrab_module_t *src )
 {
   if (!season || !number) return 0;
-  return _epg_object_set_u16(season, &season->number, number);
+  return _epg_object_set_u16(season, &season->number, number, src);
 }
 
-int epg_season_set_brand ( epg_season_t *season, epg_brand_t *brand, int u )
+int epg_season_set_brand
+  ( epg_season_t *season, epg_brand_t *brand, epggrab_module_t *src )
 {
   int save = 0;
   if ( !season || !brand ) return 0;
+  if ( !_epg_object_set_grabber(season, src) && season->brand ) return 0;
   if ( season->brand != brand ) {
     if ( season->brand ) _epg_brand_rem_season(season->brand, season);
     season->brand = brand;
@@ -529,13 +534,6 @@ int epg_season_set_brand ( epg_season_t *season, epg_brand_t *brand, int u )
   return save;
 }
 
-int epg_season_set_grabber 
-  ( epg_season_t *season, epggrab_module_t *grab, int *save )
-{
-  if (!season || !grab) return 0;
-  return _epg_object_set_grabber(season, grab, save);
-}
-
 static void _epg_season_add_episode
   ( epg_season_t *season, epg_episode_t *episode )
 {
@@ -580,15 +578,15 @@ epg_season_t *epg_season_deserialize ( htsmsg_t *m, int create, int *save )
   if ( !(es = epg_season_find_by_uri((*skel)->uri, create, save)) ) return NULL;
   
   if ( (str = htsmsg_get_str(m, "summary")) )
-    *save |= epg_season_set_summary(es, str);
+    *save |= epg_season_set_summary(es, str, NULL);
   if ( !htsmsg_get_u32(m, "number", &u32) )
-    *save |= epg_season_set_number(es, u32);
+    *save |= epg_season_set_number(es, u32, NULL);
   if ( !htsmsg_get_u32(m, "episode-count", &u32) )
-    *save |= epg_season_set_episode_count(es, u32);
+    *save |= epg_season_set_episode_count(es, u32, NULL);
   
   if ( (str = htsmsg_get_str(m, "brand")) )
     if ( (eb = epg_brand_find_by_uri(str, 0, NULL)) )
-      *save |= epg_season_set_brand(es, eb, 1);
+      *save |= epg_season_set_brand(es, eb, NULL);
 
   return es;
 }
@@ -700,76 +698,94 @@ epg_episode_t *epg_episode_find_by_id ( uint64_t id )
   return (epg_episode_t*)_epg_object_find_by_id(id, EPG_EPISODE);
 }
 
-int epg_episode_set_title ( epg_episode_t *episode, const char *title )
+int epg_episode_set_title
+  ( epg_episode_t *episode, const char *title, epggrab_module_t *src )
 {
   if (!episode || !title) return 0;
-  return _epg_object_set_str(episode, &episode->title, title);
+  return _epg_object_set_str(episode, &episode->title, title, src);
 }
 
-int epg_episode_set_subtitle ( epg_episode_t *episode, const char *subtitle )
+int epg_episode_set_subtitle
+  ( epg_episode_t *episode, const char *subtitle, epggrab_module_t *src )
 {
   if (!episode || !subtitle) return 0;
-  return _epg_object_set_str(episode, &episode->subtitle, subtitle);
+  return _epg_object_set_str(episode, &episode->subtitle, subtitle, src);
 }
 
-int epg_episode_set_summary ( epg_episode_t *episode, const char *summary )
+int epg_episode_set_summary
+  ( epg_episode_t *episode, const char *summary, epggrab_module_t *src )
 {
   if (!episode || !summary) return 0;
-  return _epg_object_set_str(episode, &episode->summary, summary);
+  return _epg_object_set_str(episode, &episode->summary, summary, src);
 }
 
-int epg_episode_set_description ( epg_episode_t *episode, const char *desc )
+int epg_episode_set_description
+  ( epg_episode_t *episode, const char *desc, epggrab_module_t *src )
 {
   if (!episode || !desc) return 0;
-  return _epg_object_set_str(episode, &episode->description, desc);
+  return _epg_object_set_str(episode, &episode->description, desc, src);
 }
 
-int epg_episode_set_image ( epg_episode_t *episode, const char *image )
+int epg_episode_set_image
+  ( epg_episode_t *episode, const char *image, epggrab_module_t *src )
 {
   if (!episode || !image) return 0;
-  return _epg_object_set_str(episode, &episode->image, image);
+  return _epg_object_set_str(episode, &episode->image, image, src);
 }
 
-int epg_episode_set_number ( epg_episode_t *episode, uint16_t number )
+int epg_episode_set_number
+  ( epg_episode_t *episode, uint16_t number, epggrab_module_t *src )
 {
   if (!episode || !number) return 0;
-  return _epg_object_set_u16(episode, &episode->epnum.e_num, number);
+  return _epg_object_set_u16(episode, &episode->epnum.e_num, number, src);
 }
 
-int epg_episode_set_part ( epg_episode_t *episode, uint16_t part, uint16_t count )
+int epg_episode_set_part
+  ( epg_episode_t *episode, uint16_t part, uint16_t count,
+    epggrab_module_t *src )
 {
   int save = 0;
   if (!episode || !part) return 0;
-  save |= _epg_object_set_u16(episode, &episode->epnum.p_num, part);
-  save |= _epg_object_set_u16(episode, &episode->epnum.p_cnt, count);
+  save |= _epg_object_set_u16(episode, &episode->epnum.p_num, part, src);
+  save |= _epg_object_set_u16(episode, &episode->epnum.p_cnt, count, src);
   return save;
 }
 
-int epg_episode_set_epnum ( epg_episode_t *episode, epg_episode_num_t *num )
+int epg_episode_set_epnum
+  ( epg_episode_t *episode, epg_episode_num_t *num, epggrab_module_t *src )
 {
   int save = 0;
   if (!episode || !num || (!num->e_num && !num->text)) return 0;
   if (num->s_num)
-    save |= _epg_object_set_u16(episode, &episode->epnum.s_num, num->s_num);
+    save |= _epg_object_set_u16(episode, &episode->epnum.s_num,
+                                num->s_num, src);
   if (num->s_cnt)
-    save |= _epg_object_set_u16(episode, &episode->epnum.s_cnt, num->s_cnt);
+    save |= _epg_object_set_u16(episode, &episode->epnum.s_cnt,
+                                num->s_cnt, src);
   if (num->e_num)
-    save |= _epg_object_set_u16(episode, &episode->epnum.e_num, num->e_num);
+    save |= _epg_object_set_u16(episode, &episode->epnum.e_num,
+                                num->e_num, src);
   if (num->e_cnt)
-    save |= _epg_object_set_u16(episode, &episode->epnum.e_cnt, num->e_cnt);
+    save |= _epg_object_set_u16(episode, &episode->epnum.e_cnt,
+                                num->e_cnt, src);
   if (num->p_num)
-    save |= _epg_object_set_u16(episode, &episode->epnum.p_num, num->p_num);
+    save |= _epg_object_set_u16(episode, &episode->epnum.p_num,
+                                num->p_num, src);
   if (num->p_cnt)
-    save |= _epg_object_set_u16(episode, &episode->epnum.p_cnt, num->p_cnt);
+    save |= _epg_object_set_u16(episode, &episode->epnum.p_cnt,
+                                num->p_cnt, src);
   if (num->text)
-    save |= _epg_object_set_str(episode, &episode->epnum.text, num->text);
+    save |= _epg_object_set_str(episode, &episode->epnum.text,
+                                num->text, src);
   return save;
 }
 
-int epg_episode_set_brand ( epg_episode_t *episode, epg_brand_t *brand )
+int epg_episode_set_brand
+  ( epg_episode_t *episode, epg_brand_t *brand, epggrab_module_t *src )
 {
   int save = 0;
   if ( !episode || !brand ) return 0;
+  if ( !_epg_object_set_grabber(episode, src) && episode->brand ) return 0;
   if ( episode->brand != brand ) {
     if ( episode->brand ) _epg_brand_rem_episode(episode->brand, episode);
     episode->brand = brand;
@@ -780,28 +796,34 @@ int epg_episode_set_brand ( epg_episode_t *episode, epg_brand_t *brand )
   return save;
 }
 
-int epg_episode_set_season ( epg_episode_t *episode, epg_season_t *season )
+int epg_episode_set_season 
+  ( epg_episode_t *episode, epg_season_t *season, epggrab_module_t *src )
 {
   int save = 0;
   if ( !episode || !season ) return 0;
+  if ( !_epg_object_set_grabber(episode, src) && episode->season ) return 0;
   if ( episode->season != season ) {
     if ( episode->season ) _epg_season_rem_episode(episode->season, episode);
     episode->season = season;
     _epg_season_add_episode(season, episode);
-    if ( season->brand ) save |= epg_episode_set_brand(episode, season->brand);
+    if ( season->brand )
+      save |= epg_episode_set_brand(episode, season->brand, src);
     _epg_object_set_updated(episode);
     save = 1;
   }
   return save;
 }
 
-int epg_episode_set_genre ( epg_episode_t *ee, epg_genre_list_t *genre )
+int epg_episode_set_genre
+  ( epg_episode_t *ee, epg_genre_list_t *genre, epggrab_module_t *src )
 {
   int save = 0;
   epg_genre_t *g1, *g2;
 
-  /* Remove old */
   g1 = LIST_FIRST(&ee->genre);
+  if (!_epg_object_set_grabber(ee, src) && g1) return 0;
+
+  /* Remove old */
   while (g1) {
     g2 = LIST_NEXT(g1, link);
     if (!epg_genre_list_contains(genre, g1, 0)) {
@@ -819,12 +841,11 @@ int epg_episode_set_genre ( epg_episode_t *ee, epg_genre_list_t *genre )
   return save;
 }
 
-int epg_episode_set_is_bw ( epg_episode_t *e, uint8_t bw )
+int epg_episode_set_is_bw
+  ( epg_episode_t *episode, uint8_t bw, epggrab_module_t *src )
 {
-  int save = 0;
-  if (!e) return 0;
-  return _epg_object_set_u8(e, &e->is_bw, bw);
-  return save;
+  if (!episode) return 0;
+  return _epg_object_set_u8(episode, &episode->is_bw, bw, src);
 }
 
 static void _epg_episode_add_broadcast 
@@ -835,13 +856,6 @@ static void _epg_episode_add_broadcast
   LIST_INSERT_SORTED(&episode->broadcasts, broadcast, ep_link, _ebc_start_cmp);
 }
 
-int epg_episode_set_grabber 
-  ( epg_episode_t *episode, epggrab_module_t *grab, int *save )
-{
-  if (!episode || !grab) return 0;
-  return _epg_object_set_grabber(episode, grab, save);
-}
-
 static void _epg_episode_rem_broadcast
   ( epg_episode_t *episode, epg_broadcast_t *broadcast )
 {
@@ -955,21 +969,22 @@ epg_episode_t *epg_episode_deserialize ( htsmsg_t *m, int create, int *save )
   epg_episode_num_t num;
   htsmsg_t *sub;
   htsmsg_field_t *f;
+  uint32_t u32;
   
   if ( !_epg_object_deserialize(m, *skel) ) return NULL;
   if ( !(ee = epg_episode_find_by_uri((*skel)->uri, create, save)) ) return NULL;
   
   if ( (str = htsmsg_get_str(m, "title")) )
-    *save |= epg_episode_set_title(ee, str);
+    *save |= epg_episode_set_title(ee, str, NULL);
   if ( (str = htsmsg_get_str(m, "subtitle")) )
-    *save |= epg_episode_set_subtitle(ee, str);
+    *save |= epg_episode_set_subtitle(ee, str, NULL);
   if ( (str = htsmsg_get_str(m, "summary")) )
-    *save |= epg_episode_set_summary(ee, str);
+    *save |= epg_episode_set_summary(ee, str, NULL);
   if ( (str = htsmsg_get_str(m, "description")) )
-    *save |= epg_episode_set_description(ee, str);
+    *save |= epg_episode_set_description(ee, str, NULL);
   if ( (sub = htsmsg_get_map(m, "epnum")) ) {
     epg_episode_num_deserialize(sub, &num);
-    *save |= epg_episode_set_epnum(ee, &num);
+    *save |= epg_episode_set_epnum(ee, &num, NULL);
     if (num.text) free(num.text);
   }
   if ( (sub = htsmsg_get_list(m, "genre")) ) {
@@ -979,18 +994,19 @@ epg_episode_t *epg_episode_deserialize ( htsmsg_t *m, int create, int *save )
       genre.code = (uint8_t)f->hmf_s64;
       epg_genre_list_add(egl, &genre);
     }
-    *save |= epg_episode_set_genre(ee, egl);
+    *save |= epg_episode_set_genre(ee, egl, NULL);
     epg_genre_list_destroy(egl);
   }
   
   if ( (str = htsmsg_get_str(m, "season")) )
     if ( (es = epg_season_find_by_uri(str, 0, NULL)) )
-      *save |= epg_episode_set_season(ee, es);
+      *save |= epg_episode_set_season(ee, es, NULL);
   if ( (str = htsmsg_get_str(m, "brand")) )
     if ( (eb = epg_brand_find_by_uri(str, 0, NULL)) )
-      *save |= epg_episode_set_brand(ee, eb);
+      *save |= epg_episode_set_brand(ee, eb, NULL);
   
-  *save |= epg_episode_set_is_bw(ee, htsmsg_get_u32_or_default(m , "is_bw", 0));
+  if (!htsmsg_get_u32(m, "is_bw", &u32))
+    *save |= epg_episode_set_is_bw(ee, u32, NULL);
 
   return ee;
 }
@@ -1202,12 +1218,15 @@ epg_broadcast_t *epg_broadcast_find_by_eid ( channel_t *ch, int eid )
 }
 
 int epg_broadcast_set_episode 
-  ( epg_broadcast_t *broadcast, epg_episode_t *episode )
+  ( epg_broadcast_t *broadcast, epg_episode_t *episode, epggrab_module_t *src )
 {
   int save = 0;
   if ( !broadcast || !episode ) return 0;
+  if ( !_epg_object_set_grabber(broadcast, src) && broadcast->episode )
+    return 0;
   if ( broadcast->episode != episode ) {
-    if ( broadcast->episode ) _epg_episode_rem_broadcast(broadcast->episode, broadcast);
+    if ( broadcast->episode )
+      _epg_episode_rem_broadcast(broadcast->episode, broadcast);
     broadcast->episode = episode;
     _epg_episode_add_broadcast(episode, broadcast);
     _epg_object_set_updated(broadcast);
@@ -1216,65 +1235,67 @@ int epg_broadcast_set_episode
   return save;
 }
 
-int epg_broadcast_set_is_widescreen ( epg_broadcast_t *b, uint8_t ws )
+int epg_broadcast_set_is_widescreen
+  ( epg_broadcast_t *b, uint8_t ws, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_widescreen, ws);
+  return _epg_object_set_u8(b, &b->is_widescreen, ws, src);
 }
 
-int epg_broadcast_set_is_hd ( epg_broadcast_t *b, uint8_t hd )
+int epg_broadcast_set_is_hd
+  ( epg_broadcast_t *b, uint8_t hd, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_hd, hd);
+  return _epg_object_set_u8(b, &b->is_hd, hd, src);
 }
 
-int epg_broadcast_set_lines ( epg_broadcast_t *b, uint16_t lines )
+int epg_broadcast_set_lines
+  ( epg_broadcast_t *b, uint16_t lines, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u16(b, &b->lines, lines);
+  return _epg_object_set_u16(b, &b->lines, lines, src);
 }
 
-int epg_broadcast_set_aspect ( epg_broadcast_t *b, uint16_t aspect )
+int epg_broadcast_set_aspect
+  ( epg_broadcast_t *b, uint16_t aspect, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u16(b, &b->aspect, aspect);
+  return _epg_object_set_u16(b, &b->aspect, aspect, src);
 }
 
-int epg_broadcast_set_is_deafsigned ( epg_broadcast_t *b, uint8_t ds )
+int epg_broadcast_set_is_deafsigned
+  ( epg_broadcast_t *b, uint8_t ds, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_deafsigned, ds);
+  return _epg_object_set_u8(b, &b->is_deafsigned, ds, src);
 }
 
-int epg_broadcast_set_is_subtitled ( epg_broadcast_t *b, uint8_t st )
+int epg_broadcast_set_is_subtitled
+  ( epg_broadcast_t *b, uint8_t st, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_subtitled, st);
+  return _epg_object_set_u8(b, &b->is_subtitled, st, src);
 }
 
-int epg_broadcast_set_is_audio_desc ( epg_broadcast_t *b, uint8_t ad )
+int epg_broadcast_set_is_audio_desc
+  ( epg_broadcast_t *b, uint8_t ad, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_audio_desc, ad);
+  return _epg_object_set_u8(b, &b->is_audio_desc, ad, src);
 }
 
-int epg_broadcast_set_is_new ( epg_broadcast_t *b, uint8_t n )
+int epg_broadcast_set_is_new
+  ( epg_broadcast_t *b, uint8_t n, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_new, n);
+  return _epg_object_set_u8(b, &b->is_new, n, src);
 }
 
-int epg_broadcast_set_is_repeat ( epg_broadcast_t *b, uint8_t r )
+int epg_broadcast_set_is_repeat
+  ( epg_broadcast_t *b, uint8_t r, epggrab_module_t *src )
 {
   if (!b) return 0;
-  return _epg_object_set_u8(b, &b->is_repeat, r);
-}
-
-int epg_broadcast_set_grabber 
-  ( epg_broadcast_t *broadcast, epggrab_module_t *grab, int *save )
-{
-  if (!broadcast || !grab) return 0;
-  return _epg_object_set_grabber(broadcast, grab, save);
+  return _epg_object_set_u8(b, &b->is_repeat, r, src);
 }
 
 epg_broadcast_t *epg_broadcast_get_next ( epg_broadcast_t *broadcast )
@@ -1357,26 +1378,26 @@ epg_broadcast_t *epg_broadcast_deserialize
 
   /* Get metadata */
   if (!htsmsg_get_u32(m, "is_widescreen", &u32))
-    *save |= epg_broadcast_set_is_widescreen(ebc, u32);
+    *save |= epg_broadcast_set_is_widescreen(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "is_hd", &u32))
-    *save |= epg_broadcast_set_is_hd(ebc, u32);
+    *save |= epg_broadcast_set_is_hd(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "lines", &u32))
-    *save |= epg_broadcast_set_lines(ebc, u32);
+    *save |= epg_broadcast_set_lines(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "aspect", &u32))
-    *save |= epg_broadcast_set_aspect(ebc, u32);
+    *save |= epg_broadcast_set_aspect(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "is_deafsigned", &u32))
-    *save |= epg_broadcast_set_is_deafsigned(ebc, u32);
+    *save |= epg_broadcast_set_is_deafsigned(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "is_subtitled", &u32))
-    *save |= epg_broadcast_set_is_subtitled(ebc, u32);
+    *save |= epg_broadcast_set_is_subtitled(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "is_audio_desc", &u32))
-    *save |= epg_broadcast_set_is_audio_desc(ebc, u32);
+    *save |= epg_broadcast_set_is_audio_desc(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "is_new", &u32))
-    *save |= epg_broadcast_set_is_new(ebc, u32);
+    *save |= epg_broadcast_set_is_new(ebc, u32, NULL);
   if (!htsmsg_get_u32(m, "is_repeat", &u32))
-    *save |= epg_broadcast_set_is_repeat(ebc, u32);
+    *save |= epg_broadcast_set_is_repeat(ebc, u32, NULL);
 
   /* Set the episode */
-  *save |= epg_broadcast_set_episode(ebc, ee);
+  *save |= epg_broadcast_set_episode(ebc, ee, NULL);
 
   return ebc;
 }

diff --git a/src/epg.h b/src/epg.h
index cd412f5e15ce55f665127563cafc28e26d62b5de..0735718408580efa84f6dfa9bac552caa1365628 100644 (file)
--- a/src/epg.h
+++ b/src/epg.h
@@ -151,17 +151,17 @@ epg_brand_t *epg_brand_find_by_uri
 epg_brand_t *epg_brand_find_by_id ( uint64_t id );
 
 /* Mutators */
-int epg_brand_set_title        ( epg_brand_t *b, const char *title )
+int epg_brand_set_title        
+  ( epg_brand_t *b, const char *title, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_brand_set_summary      ( epg_brand_t *b, const char *summary )
+int epg_brand_set_summary
+  ( epg_brand_t *b, const char *summary, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_brand_set_season_count ( epg_brand_t *b, uint16_t season_count )
+int epg_brand_set_season_count
+  ( epg_brand_t *b, uint16_t season_count, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_brand_set_image        ( epg_brand_t *b, const char *i )
-  __attribute__((warn_unused_result));
-
-int epg_brand_set_grabber
-  ( epg_brand_t *b, struct epggrab_module *grab, int *save )
+int epg_brand_set_image
+  ( epg_brand_t *b, const char *i, struct epggrab_module *src )
   __attribute__((warn_unused_result));
 
 /* Serialization */
@@ -197,19 +197,20 @@ epg_season_t *epg_season_find_by_uri
 epg_season_t *epg_season_find_by_id ( uint64_t id );
 
 /* Mutators */
-int epg_season_set_summary       ( epg_season_t *s, const char *summary )
+int epg_season_set_summary
+  ( epg_season_t *s, const char *summary, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_season_set_number        ( epg_season_t *s, uint16_t number )
+int epg_season_set_number
+  ( epg_season_t *s, uint16_t number, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_season_set_episode_count ( epg_season_t *s, uint16_t episode_count )
+int epg_season_set_episode_count
+  ( epg_season_t *s, uint16_t episode_count, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_season_set_brand         ( epg_season_t *s, epg_brand_t *b, int u )
+int epg_season_set_brand
+  ( epg_season_t *s, epg_brand_t *b, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_season_set_image         ( epg_season_t *s, const char *image )
-  __attribute__((warn_unused_result));
-
-int epg_season_set_grabber
-  ( epg_season_t *s, struct epggrab_module *grab, int *save )
+int epg_season_set_image
+  ( epg_season_t *s, const char *image, struct epggrab_module *src )
   __attribute__((warn_unused_result));
 
 /* Serialization */
@@ -265,36 +266,42 @@ epg_episode_t *epg_episode_find_by_uri
 epg_episode_t *epg_episode_find_by_id ( uint64_t id );
 
 /* Mutators */
-int epg_episode_set_title        ( epg_episode_t *e, const char *title )
-  __attribute__((warn_unused_result));
-int epg_episode_set_subtitle     ( epg_episode_t *e, const char *subtitle )
+int epg_episode_set_title
+  ( epg_episode_t *e, const char *title, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_summary      ( epg_episode_t *e, const char *summary )
+int epg_episode_set_subtitle
+  ( epg_episode_t *e, const char *subtitle, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_description  ( epg_episode_t *e, const char *description )
+int epg_episode_set_summary
+  ( epg_episode_t *e, const char *summary, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_number       ( epg_episode_t *e, uint16_t number )
+int epg_episode_set_description
+  ( epg_episode_t *e, const char *description, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_part         ( epg_episode_t *e, 
-                                   uint16_t number, uint16_t count )
+int epg_episode_set_number
+  ( epg_episode_t *e, uint16_t number, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_epnum        ( epg_episode_t *e, epg_episode_num_t *num )
+int epg_episode_set_part
+  ( epg_episode_t *e, uint16_t number, uint16_t count,
+    struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_brand        ( epg_episode_t *e, epg_brand_t *b )
+int epg_episode_set_epnum
+  ( epg_episode_t *e, epg_episode_num_t *num, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_season       ( epg_episode_t *e, epg_season_t *s )
+int epg_episode_set_brand
+  ( epg_episode_t *e, epg_brand_t *b, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_genre        ( epg_episode_t *e, epg_genre_list_t *g )
+int epg_episode_set_season
+  ( epg_episode_t *e, epg_season_t *s, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_genre_str    ( epg_episode_t *e, const char **s )
+int epg_episode_set_genre
+  ( epg_episode_t *e, epg_genre_list_t *g, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_image        ( epg_episode_t *e, const char *i )
+int epg_episode_set_image
+  ( epg_episode_t *e, const char *i, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_episode_set_is_bw ( epg_episode_t *b, uint8_t bw )
-  __attribute__((warn_unused_result));
-
-int epg_episode_set_grabber
-  ( epg_episode_t *e, struct epggrab_module *grab, int *save )
+int epg_episode_set_is_bw
+  ( epg_episode_t *b, uint8_t bw, struct epggrab_module *src )
   __attribute__((warn_unused_result));
 
 // Note: this does NOT strdup the text field
@@ -370,29 +377,35 @@ epg_broadcast_t *epg_broadcast_find_by_eid ( struct channel *ch, int eid );
 epg_broadcast_t *epg_broadcast_find_by_id  ( uint64_t id, struct channel *ch );
 
 /* Mutators */
-int epg_broadcast_set_episode    ( epg_broadcast_t *b, epg_episode_t *e )
+int epg_broadcast_set_episode
+  ( epg_broadcast_t *b, epg_episode_t *e, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_widescreen ( epg_broadcast_t *b, uint8_t ws )
+int epg_broadcast_set_is_widescreen
+  ( epg_broadcast_t *b, uint8_t ws, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_hd ( epg_broadcast_t *b, uint8_t hd )
+int epg_broadcast_set_is_hd
+  ( epg_broadcast_t *b, uint8_t hd, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_lines ( epg_broadcast_t *b, uint16_t lines )
+int epg_broadcast_set_lines 
+  ( epg_broadcast_t *b, uint16_t lines, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_aspect ( epg_broadcast_t *b, uint16_t aspect )
+int epg_broadcast_set_aspect
+  ( epg_broadcast_t *b, uint16_t aspect, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_deafsigned ( epg_broadcast_t *b, uint8_t ds )
+int epg_broadcast_set_is_deafsigned
+  ( epg_broadcast_t *b, uint8_t ds, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_subtitled ( epg_broadcast_t *b, uint8_t st )
+int epg_broadcast_set_is_subtitled
+  ( epg_broadcast_t *b, uint8_t st, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_audio_desc ( epg_broadcast_t *b, uint8_t ad )
+int epg_broadcast_set_is_audio_desc
+  ( epg_broadcast_t *b, uint8_t ad, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_new ( epg_broadcast_t *b, uint8_t n )
+int epg_broadcast_set_is_new
+  ( epg_broadcast_t *b, uint8_t n, struct epggrab_module *src )
   __attribute__((warn_unused_result));
-int epg_broadcast_set_is_repeat ( epg_broadcast_t *b, uint8_t r )
-  __attribute__((warn_unused_result));
-
-int epg_broadcast_set_grabber
-  ( epg_broadcast_t *b, struct epggrab_module *grab, int *save )
+int epg_broadcast_set_is_repeat
+  ( epg_broadcast_t *b, uint8_t r, struct epggrab_module *src )
   __attribute__((warn_unused_result));
 
 /* Accessors */

diff --git a/src/epgdb.c b/src/epgdb.c
index 41f9ca52c5e4385e87e061ff0be2e8b19fb0d9b3..438430440fb214c301e66c7849266da4f1f884a9 100644 (file)
--- a/src/epgdb.c
+++ b/src/epgdb.c
@@ -77,20 +77,20 @@ static void _epgdb_v1_process ( htsmsg_t *c, epggrab_stats_t *stats )
   if (!ee) return;
   if (save) stats->episodes.total++;
   if (title)
-    save |= epg_episode_set_title(ee, title);
+    save |= epg_episode_set_title(ee, title, NULL);
   if (desc)
-    save |= epg_episode_set_summary(ee, desc);
+    save |= epg_episode_set_summary(ee, desc, NULL);
   if (!htsmsg_get_u32(c, "episode", &u32))
-    save |= epg_episode_set_number(ee, u32);
+    save |= epg_episode_set_number(ee, u32, NULL);
   if (!htsmsg_get_u32(c, "part", &u32))
-    save |= epg_episode_set_part(ee, u32, 0);
+    save |= epg_episode_set_part(ee, u32, 0, NULL);
   if (!htsmsg_get_u32(c, "season", &u32))
     ee->epnum.s_num = u32;
   if ((str = htsmsg_get_str(c, "epname")))
     ee->epnum.text  = strdup(str);
 
   /* Set episode */
-  save |= epg_broadcast_set_episode(ebc, ee);
+  save |= epg_broadcast_set_episode(ebc, ee, NULL);
 }
 
 /*