From 95d8d19797325fae54e9c4fe0d7de92d5794cc25 Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Tue, 10 Jul 2012 19:58:02 +0100 Subject: [PATCH 1/9] Add initial priority information, currently unused. --- src/epg.c | 39 +++++++++++++++++++++++++++++++++++++++ src/epg.h | 23 +++++++++++++++++++++-- src/epggrab.h | 1 + 3 files changed, 61 insertions(+), 2 deletions(-) diff --git a/src/epg.c b/src/epg.c index 15c146a6..9dda892d 100644 --- a/src/epg.c +++ b/src/epg.c @@ -263,6 +263,17 @@ 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 * *************************************************************************/ @@ -340,6 +351,13 @@ int epg_brand_set_season_count ( epg_brand_t *brand, uint16_t count ) 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); +} + static void _epg_brand_add_season ( epg_brand_t *brand, epg_season_t *season ) { @@ -506,6 +524,13 @@ 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 ) { @@ -805,6 +830,13 @@ 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 ) { @@ -1233,6 +1265,13 @@ int epg_broadcast_set_is_repeat ( epg_broadcast_t *b, uint8_t r ) 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); +} + epg_broadcast_t *epg_broadcast_get_next ( epg_broadcast_t *broadcast ) { if ( !broadcast ) return NULL; diff --git a/src/epg.h b/src/epg.h index e04365b5..cd412f5e 100644 --- a/src/epg.h +++ b/src/epg.h @@ -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 @@ -22,10 +22,11 @@ #include "settings.h" /* - * Forward decls + * External forward decls */ struct channel; struct channel_tag; +struct epggrab_module; /* * Map/List types @@ -117,6 +118,8 @@ struct epg_object int refcount; ///< Reference counting // Note: could use LIST_ENTRY field to determine this! + struct epggrab_module *grabber; ///< Originating grabber + void (*getref) ( void *o ); ///< Get a reference void (*putref) ( void *o ); ///< Release a reference void (*destroy) ( void *o ); ///< Delete the object @@ -157,6 +160,10 @@ int epg_brand_set_season_count ( epg_brand_t *b, uint16_t season_count ) 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 ) + __attribute__((warn_unused_result)); + /* Serialization */ htsmsg_t *epg_brand_serialize ( epg_brand_t *b ); epg_brand_t *epg_brand_deserialize ( htsmsg_t *m, int create, int *save ); @@ -201,6 +208,10 @@ int epg_season_set_brand ( epg_season_t *s, epg_brand_t *b, int u ) 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 ) + __attribute__((warn_unused_result)); + /* Serialization */ htsmsg_t *epg_season_serialize ( epg_season_t *b ); epg_season_t *epg_season_deserialize ( htsmsg_t *m, int create, int *save ); @@ -282,6 +293,10 @@ int epg_episode_set_image ( epg_episode_t *e, const char *i ) 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 ) + __attribute__((warn_unused_result)); + // Note: this does NOT strdup the text field void epg_episode_get_epnum ( epg_episode_t *e, epg_episode_num_t *epnum ); @@ -376,6 +391,10 @@ int epg_broadcast_set_is_new ( epg_broadcast_t *b, uint8_t n ) 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 ) + __attribute__((warn_unused_result)); + /* Accessors */ epg_broadcast_t *epg_broadcast_get_next ( epg_broadcast_t *b ); diff --git a/src/epggrab.h b/src/epggrab.h index ead00f65..9583e0ad 100644 --- a/src/epggrab.h +++ b/src/epggrab.h @@ -120,6 +120,7 @@ struct epggrab_module const char *id; ///< Module identifier const char *name; ///< Module name (for display) uint8_t enabled; ///< Whether the module is enabled + int priority; ///< Priority of the module epggrab_channel_tree_t *channels; ///< Channel list /* Enable/Disable */ From acdcd7bbd50fad689fb9be5dd2299d828398de5c Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Tue, 10 Jul 2012 20:27:04 +0100 Subject: [PATCH 2/9] Add parsing of mod priority configuration. --- src/epggrab.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/src/epggrab.c b/src/epggrab.c index 0c52ea6c..fdb64456 100644 --- a/src/epggrab.c +++ b/src/epggrab.c @@ -103,6 +103,7 @@ static void* _epggrab_internal_thread ( void* p ) static void _epggrab_load ( void ) { epggrab_module_t *mod; + htsmsg_field_t *f; htsmsg_t *m, *a; uint32_t enabled = 1; const char *str; @@ -120,8 +121,10 @@ static void _epggrab_load ( void ) htsmsg_get_u32(m, "channel_rename", &epggrab_channel_rename); htsmsg_get_u32(m, "channel_renumber", &epggrab_channel_renumber); htsmsg_get_u32(m, "channel_reicon", &epggrab_channel_reicon); - if (!htsmsg_get_u32(m, old ? "grab-interval" : "interval", &epggrab_interval)) + if (!htsmsg_get_u32(m, old ? "grab-interval" : "interval", + &epggrab_interval)) { if (old) epggrab_interval *= 3600; + } htsmsg_get_u32(m, "grab-enabled", &enabled); if (enabled) { if ( (str = htsmsg_get_str(m, old ? "current-grabber" : "module")) ) { @@ -133,16 +136,24 @@ static void _epggrab_load ( void ) if ( (a = htsmsg_get_map(m, "mod_enabled")) ) { LIST_FOREACH(mod, &epggrab_modules, link) { if (htsmsg_get_u32_or_default(a, mod->id, 0)) { - epggrab_enable_module(mod, 1); + epggrab_enable_module(mod, 1); } } } + if ( (a = htsmsg_get_list(m, "mod_priority")) ) { + int prio = 1; + LIST_FOREACH(mod, &epggrab_modules, link) + mod->priority = 0; + HTSMSG_FOREACH(f, a) { + mod = epggrab_module_find_by_id(f->hmf_str); + if (mod) mod->priority = prio++; + } + } } htsmsg_destroy(m); /* Finish up migration */ if (old) { - htsmsg_field_t *f; htsmsg_t *xc, *ch; htsmsg_t *xchs = hts_settings_load("xmltv/channels"); htsmsg_t *chs = hts_settings_load("channels"); From f3b2eca1862d5d2909b8abde76400b965c3cf236 Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Tue, 10 Jul 2012 20:34:04 +0100 Subject: [PATCH 3/9] Add default priority setting in grab modules. --- src/epggrab/module.c | 16 +++++++++------- src/epggrab/module/eit.c | 2 +- src/epggrab/module/opentv.c | 2 +- src/epggrab/module/pyepg.c | 5 +++-- src/epggrab/module/xmltv.c | 4 ++-- src/epggrab/private.h | 11 +++++++---- 6 files changed, 23 insertions(+), 17 deletions(-) diff --git a/src/epggrab/module.c b/src/epggrab/module.c index 7217426f..a2b3bdcf 100644 --- a/src/epggrab/module.c +++ b/src/epggrab/module.c @@ -73,7 +73,7 @@ htsmsg_t *epggrab_module_list ( void ) * *************************************************************************/ epggrab_module_t *epggrab_module_create - ( epggrab_module_t *skel, const char *id, const char *name, + ( epggrab_module_t *skel, const char *id, const char *name, int priority, epggrab_channel_tree_t *channels ) { assert(skel); @@ -81,6 +81,7 @@ epggrab_module_t *epggrab_module_create /* Setup */ skel->id = strdup(id); skel->name = strdup(name); + skel->priority = priority; skel->channels = channels; if (channels) { skel->ch_save = epggrab_module_ch_save; @@ -227,7 +228,8 @@ void epggrab_module_channels_load ( epggrab_module_t *mod ) epggrab_module_int_t *epggrab_module_int_create ( epggrab_module_int_t *skel, - const char *id, const char *name, const char *path, + const char *id, const char *name, int priority, + const char *path, char* (*grab) (void*m), int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta), htsmsg_t* (*trans) (void *mod, char *data), @@ -237,7 +239,7 @@ epggrab_module_int_t *epggrab_module_int_create if (!skel) skel = calloc(1, sizeof(epggrab_module_int_t)); /* Pass through */ - epggrab_module_create((epggrab_module_t*)skel, id, name, channels); + epggrab_module_create((epggrab_module_t*)skel, id, name, priority, channels); /* Int data */ skel->type = EPGGRAB_INT; @@ -397,7 +399,7 @@ int epggrab_module_enable_socket ( void *m, uint8_t e ) */ epggrab_module_ext_t *epggrab_module_ext_create ( epggrab_module_ext_t *skel, - const char *id, const char *name, const char *sockid, + const char *id, const char *name, int priority, const char *sockid, int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta), htsmsg_t* (*trans) (void *mod, char *data), epggrab_channel_tree_t *channels ) @@ -411,7 +413,7 @@ epggrab_module_ext_t *epggrab_module_ext_create snprintf(path, 512, "%s/epggrab/%s.sock", hts_settings_get_root(), sockid); epggrab_module_int_create((epggrab_module_int_t*)skel, - id, name, path, + id, name, priority, path, NULL, parse, trans, channels); @@ -428,7 +430,7 @@ epggrab_module_ext_t *epggrab_module_ext_create epggrab_module_ota_t *epggrab_module_ota_create ( epggrab_module_ota_t *skel, - const char *id, const char *name, + const char *id, const char *name, int priority, void (*start) (epggrab_module_ota_t*m, struct th_dvb_mux_instance *tdmi), int (*enable) (void *m, uint8_t e ), @@ -437,7 +439,7 @@ epggrab_module_ota_t *epggrab_module_ota_create if (!skel) skel = calloc(1, sizeof(epggrab_module_ota_t)); /* Pass through */ - epggrab_module_create((epggrab_module_t*)skel, id, name, channels); + epggrab_module_create((epggrab_module_t*)skel, id, name, priority, channels); /* Setup */ skel->type = EPGGRAB_OTA; diff --git a/src/epggrab/module/eit.c b/src/epggrab/module/eit.c index 5889b0ed..428664ab 100644 --- a/src/epggrab/module/eit.c +++ b/src/epggrab/module/eit.c @@ -431,7 +431,7 @@ static void _eit_start void eit_init ( void ) { - epggrab_module_ota_create(NULL, "eit", "EIT: DVB Grabber", + epggrab_module_ota_create(NULL, "eit", "EIT: DVB Grabber", 1, _eit_start, NULL, NULL); } diff --git a/src/epggrab/module/opentv.c b/src/epggrab/module/opentv.c index 8e8c8f93..18c77f7c 100644 --- a/src/epggrab/module/opentv.c +++ b/src/epggrab/module/opentv.c @@ -874,7 +874,7 @@ static int _opentv_prov_load_one ( const char *id, htsmsg_t *m ) sprintf(nbuf, "OpenTV: %s", name); mod = (opentv_module_t*) epggrab_module_ota_create(calloc(1, sizeof(opentv_module_t)), - ibuf, nbuf, + ibuf, nbuf, 2, _opentv_start, _opentv_enable, NULL); diff --git a/src/epggrab/module/pyepg.c b/src/epggrab/module/pyepg.c index 621eb743..3f0679a4 100644 --- a/src/epggrab/module/pyepg.c +++ b/src/epggrab/module/pyepg.c @@ -416,12 +416,13 @@ static int _pyepg_parse void pyepg_init ( void ) { /* Internal module */ - epggrab_module_int_create(NULL, "/usr/bin/pyepg", "PyEPG", "/usr/bin/pyepg", + epggrab_module_int_create(NULL, "/usr/bin/pyepg", "PyEPG", 4, + "/usr/bin/pyepg", NULL, _pyepg_parse, NULL, NULL); /* External module */ _pyepg_module = (epggrab_module_t*) - epggrab_module_ext_create(NULL, "pyepg", "PyEPG", "pyepg", + epggrab_module_ext_create(NULL, "pyepg", "PyEPG", 4, "pyepg", _pyepg_parse, NULL, &_pyepg_channels); } diff --git a/src/epggrab/module/xmltv.c b/src/epggrab/module/xmltv.c index 38cbf0e8..774ed73d 100644 --- a/src/epggrab/module/xmltv.c +++ b/src/epggrab/module/xmltv.c @@ -501,7 +501,7 @@ static void _xmltv_load_grabbers ( void ) if ( outbuf[i] == '\n' || outbuf[i] == '\0' ) { outbuf[i] = '\0'; sprintf(name, "XMLTV: %s", &outbuf[n]); - epggrab_module_int_create(NULL, &outbuf[p], name, &outbuf[p], + epggrab_module_int_create(NULL, &outbuf[p], name, 3, &outbuf[p], NULL, _xmltv_parse, NULL, NULL); p = n = i + 1; } else if ( outbuf[i] == '|' ) { @@ -517,7 +517,7 @@ void xmltv_init ( void ) { /* External module */ _xmltv_module = (epggrab_module_t*) - epggrab_module_ext_create(NULL, "xmltv", "XMLTV", "xmltv", + epggrab_module_ext_create(NULL, "xmltv", "XMLTV", 3, "xmltv", _xmltv_parse, NULL, &_xmltv_channels); diff --git a/src/epggrab/private.h b/src/epggrab/private.h index 875422c2..e1abe0da 100644 --- a/src/epggrab/private.h +++ b/src/epggrab/private.h @@ -25,7 +25,8 @@ epggrab_module_t *epggrab_module_create ( epggrab_module_t *skel, - const char *id, const char *name, epggrab_channel_tree_t *channels ); + const char *id, const char *name, int priority, + epggrab_channel_tree_t *channels ); char *epggrab_module_grab_spawn ( void *m ); htsmsg_t *epggrab_module_trans_xml ( void *m, char *data ); @@ -57,7 +58,8 @@ epggrab_channel_t *epggrab_channel_find epggrab_module_int_t *epggrab_module_int_create ( epggrab_module_int_t *skel, - const char *id, const char *name, const char *path, + const char *id, const char *name, int priority, + const char *path, char* (*grab) (void*m), int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta), htsmsg_t* (*trans) (void *mod, char *data), @@ -69,7 +71,8 @@ epggrab_module_int_t *epggrab_module_int_create epggrab_module_ext_t *epggrab_module_ext_create ( epggrab_module_ext_t *skel, - const char *id, const char *name, const char *sockid, + const char *id, const char *name, int priority, + const char *sockid, int (*parse) (void *m, htsmsg_t *data, epggrab_stats_t *sta), htsmsg_t* (*trans) (void *mod, char *data), epggrab_channel_tree_t *channels ); @@ -80,7 +83,7 @@ epggrab_module_ext_t *epggrab_module_ext_create epggrab_module_ota_t *epggrab_module_ota_create ( epggrab_module_ota_t *skel, - const char *id, const char *name, + const char *id, const char *name, int priority, void (*start) (epggrab_module_ota_t*m, struct th_dvb_mux_instance *tdmi), int (*enable) (void *m, uint8_t e ), From 8d6d53f3325dbe1765c1a0b98ac4f7869b6514e2 Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Tue, 10 Jul 2012 21:31:20 +0100 Subject: [PATCH 4/9] Ensure epg object grabber is persisted to disk. --- src/epg.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/epg.c b/src/epg.c index 9dda892d..a6242691 100644 --- a/src/epg.c +++ b/src/epg.c @@ -213,14 +213,19 @@ static htsmsg_t * _epg_object_serialize ( void *o ) htsmsg_add_u32(m, "type", eo->type); if (eo->uri) htsmsg_add_str(m, "uri", eo->uri); + if (eo->grabber) + htsmsg_add_str(m, "grabber", eo->grabber->id); return m; } static epg_object_t *_epg_object_deserialize ( htsmsg_t *m, epg_object_t *eo ) { + const char *s; if (htsmsg_get_u64(m, "id", &eo->id)) return NULL; if (htsmsg_get_u32(m, "type", &eo->type)) return NULL; eo->uri = (char*)htsmsg_get_str(m, "uri"); + if ((s = htsmsg_get_str(m, "grabber"))) + eo->grabber = epggrab_module_find_by_id(s); return eo; } From fab0712d89185fbbcad05bf928d91cf9aeb12444 Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Tue, 10 Jul 2012 21:52:38 +0100 Subject: [PATCH 5/9] Start to work in priority handling to EIT and OpenTV. --- src/epggrab/module/eit.c | 20 ++++++++++++-------- src/epggrab/module/opentv.c | 34 +++++++++++++++++++--------------- 2 files changed, 31 insertions(+), 23 deletions(-) diff --git a/src/epggrab/module/eit.c b/src/epggrab/module/eit.c index 428664ab..043798cb 100644 --- a/src/epggrab/module/eit.c +++ b/src/epggrab/module/eit.c @@ -162,6 +162,7 @@ static int _eit_callback char summary[256]; char desc[5000]; htsmsg_t *extra; + int update; /* Invalid */ if(tableid < 0x4e || tableid > 0x6f || len < 11) @@ -362,8 +363,9 @@ static int _eit_callback len -= dlen; ptr += dlen; dllen -= dlen; } - /* Metadata */ - if ( save2 ) { + /* Broadcast Metadata */ + update = epg_broadcast_set_grabber(ebc, (epggrab_module_t*)mod, &save); + if (update) { save |= epg_broadcast_set_is_hd(ebc, hd); save |= epg_broadcast_set_is_widescreen(ebc, ws); save |= epg_broadcast_set_is_audio_desc(ebc, ad); @@ -377,7 +379,7 @@ static int _eit_callback char *uri; uri = epg_hash(title, summary, desc); if (uri) { - if ((ee = epg_episode_find_by_uri(uri, 1, &save2))) + if ((ee = epg_episode_find_by_uri(uri, 1, &save2)) && update) save |= epg_broadcast_set_episode(ebc, ee); free(uri); } @@ -386,14 +388,16 @@ static int _eit_callback /* Episode data */ if (ee) { - save |= epg_episode_set_is_bw(ee, bw); - if ( !ee->title && *title ) + update = epg_episode_set_grabber(ee, (epggrab_module_t*)mod, &save); + if (update) + save |= epg_episode_set_is_bw(ee, bw); + if ( *title && (update || !ee->title) ) save |= epg_episode_set_title(ee, title); - if ( !ee->summary && *summary ) + if ( *summary && (update || !ee->summary) ) save |= epg_episode_set_summary(ee, summary); - if ( !ee->description && *desc ) + if ( *desc && (update || !ee->description) ) save |= epg_episode_set_description(ee, desc); - if ( !LIST_FIRST(&ee->genre) && egl ) + if ( egl && (update || !LIST_FIRST(&ee->genre)) ) save |= epg_episode_set_genre(ee, egl); #if TODO_ADD_EXTRA if ( extra ) diff --git a/src/epggrab/module/opentv.c b/src/epggrab/module/opentv.c index 18c77f7c..355d1844 100644 --- a/src/epggrab/module/opentv.c +++ b/src/epggrab/module/opentv.c @@ -341,7 +341,7 @@ static int _opentv_parse_event_section ( opentv_module_t *mod, opentv_status_t *sta, uint8_t *buf, int len, int type ) { - int i, cid, save = 0; + int i, cid, update, save = 0; time_t mjd; char *uri; epggrab_channel_t *ec; @@ -381,10 +381,11 @@ static int _opentv_parse_event_section /* Find episode */ if (ebc) { - ee = NULL; + update = epg_broadcast_set_grabber(ebc, (epggrab_module_t*)mod, &save); + ee = NULL; /* Find episode */ - if (ev.type & OPENTV_SUMMARY || !ebc->episode) { + if ((update && (ev.type & OPENTV_SUMMARY)) || !ebc->episode) { uri = epg_hash(ev.title, ev.summary, ev.desc); if (uri) { ee = epg_episode_find_by_uri(uri, 1, &save); @@ -392,33 +393,36 @@ static int _opentv_parse_event_section } } + /* Copy existing title */ + if (!ev.title && ebc->episode && ebc->episode->title) + ev.title = strdup(ebc->episode->title); + /* Use existing */ - if (!ee) ee = ebc->episode; + if (!ee) + ee = ebc->episode; + else if (update || !ebc->episode) + save |= epg_broadcast_set_episode(ebc, ee); /* Update */ if (ee) { - if (!ev.title && ebc->episode) - save |= epg_episode_set_title(ee, ebc->episode->title); - else if (ev.title) + update = epg_episode_set_grabber(ee, (epggrab_module_t*)mod, &save); + + if (ev.title && (update || !ee->title)) save |= epg_episode_set_title(ee, ev.title); - if (ev.summary) + if (ev.summary && (update || !ee->summary)) save |= epg_episode_set_summary(ee, ev.summary); - if (ev.desc) + if (ev.desc && (update || !ee->description)) save |= epg_episode_set_description(ee, ev.desc); - if (ev.cat) { + if (ev.cat && (update || !LIST_FIRST(&ee->genre))) { epg_genre_list_t *egl = calloc(1, sizeof(epg_genre_list_t)); epg_genre_list_add_by_eit(egl, ev.cat); save |= epg_episode_set_genre(ee, egl); epg_genre_list_destroy(egl); } - // Note: don't override the season (since the ID is channel specific - // it'll keep changing! - if (ev.series && !ee->season) { + if (ev.series && (update || !ee->season)) { es = _opentv_find_season(mod, cid, ev.series); if (es) save |= epg_episode_set_season(ee, es); } - - save |= epg_broadcast_set_episode(ebc, ee); } } From 89f232839d11a60eb46aee0fd34bea2b555dafdd Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Wed, 11 Jul 2012 10:16:53 +0100 Subject: [PATCH 6/9] Updated EPG methods to include source epggrab_module to ensure priorities are properly adhered to. --- src/epg.c | 303 ++++++++++++++++++++++++++++------------------------ src/epg.h | 113 +++++++++++--------- src/epgdb.c | 10 +- 3 files changed, 230 insertions(+), 196 deletions(-) diff --git a/src/epg.c b/src/epg.c index a6242691..35583693 100644 --- 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_str - ( void *o, char **old, const char *new ) +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, 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 cd412f5e..07357184 100644 --- 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 ) +int epg_episode_set_title + ( epg_episode_t *e, const char *title, struct epggrab_module *src ) __attribute__((warn_unused_result)); -int epg_episode_set_subtitle ( epg_episode_t *e, const char *subtitle ) +int epg_episode_set_subtitle + ( epg_episode_t *e, const char *subtitle, struct epggrab_module *src ) __attribute__((warn_unused_result)); -int epg_episode_set_summary ( epg_episode_t *e, const char *summary ) +int epg_episode_set_summary + ( epg_episode_t *e, const char *summary, struct epggrab_module *src ) __attribute__((warn_unused_result)); -int epg_episode_set_description ( epg_episode_t *e, const char *description ) +int epg_episode_set_description + ( epg_episode_t *e, const char *description, struct epggrab_module *src ) __attribute__((warn_unused_result)); -int epg_episode_set_number ( epg_episode_t *e, uint16_t number ) +int epg_episode_set_number + ( epg_episode_t *e, uint16_t number, 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_part + ( epg_episode_t *e, uint16_t number, uint16_t count, + 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_epnum + ( epg_episode_t *e, epg_episode_num_t *num, 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_brand + ( epg_episode_t *e, epg_brand_t *b, 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_season + ( epg_episode_t *e, epg_season_t *s, 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_genre + ( epg_episode_t *e, epg_genre_list_t *g, 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_image + ( epg_episode_t *e, const char *i, struct epggrab_module *src ) __attribute__((warn_unused_result)); -int epg_episode_set_image ( epg_episode_t *e, const char *i ) - __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 41f9ca52..43843044 100644 --- 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); } /* From 10f3d893ad984829e54dede3cefc4280fd22a336 Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Wed, 11 Jul 2012 10:18:30 +0100 Subject: [PATCH 7/9] Revert earlier changes to EIT and OpenTV, now have a new API. --- src/epggrab/module/eit.c | 20 ++++++++------------ src/epggrab/module/opentv.c | 34 +++++++++++++++------------------- 2 files changed, 23 insertions(+), 31 deletions(-) diff --git a/src/epggrab/module/eit.c b/src/epggrab/module/eit.c index 043798cb..428664ab 100644 --- a/src/epggrab/module/eit.c +++ b/src/epggrab/module/eit.c @@ -162,7 +162,6 @@ static int _eit_callback char summary[256]; char desc[5000]; htsmsg_t *extra; - int update; /* Invalid */ if(tableid < 0x4e || tableid > 0x6f || len < 11) @@ -363,9 +362,8 @@ static int _eit_callback len -= dlen; ptr += dlen; dllen -= dlen; } - /* Broadcast Metadata */ - update = epg_broadcast_set_grabber(ebc, (epggrab_module_t*)mod, &save); - if (update) { + /* Metadata */ + if ( save2 ) { save |= epg_broadcast_set_is_hd(ebc, hd); save |= epg_broadcast_set_is_widescreen(ebc, ws); save |= epg_broadcast_set_is_audio_desc(ebc, ad); @@ -379,7 +377,7 @@ static int _eit_callback char *uri; uri = epg_hash(title, summary, desc); if (uri) { - if ((ee = epg_episode_find_by_uri(uri, 1, &save2)) && update) + if ((ee = epg_episode_find_by_uri(uri, 1, &save2))) save |= epg_broadcast_set_episode(ebc, ee); free(uri); } @@ -388,16 +386,14 @@ static int _eit_callback /* Episode data */ if (ee) { - update = epg_episode_set_grabber(ee, (epggrab_module_t*)mod, &save); - if (update) - save |= epg_episode_set_is_bw(ee, bw); - if ( *title && (update || !ee->title) ) + save |= epg_episode_set_is_bw(ee, bw); + if ( !ee->title && *title ) save |= epg_episode_set_title(ee, title); - if ( *summary && (update || !ee->summary) ) + if ( !ee->summary && *summary ) save |= epg_episode_set_summary(ee, summary); - if ( *desc && (update || !ee->description) ) + if ( !ee->description && *desc ) save |= epg_episode_set_description(ee, desc); - if ( egl && (update || !LIST_FIRST(&ee->genre)) ) + if ( !LIST_FIRST(&ee->genre) && egl ) save |= epg_episode_set_genre(ee, egl); #if TODO_ADD_EXTRA if ( extra ) diff --git a/src/epggrab/module/opentv.c b/src/epggrab/module/opentv.c index 355d1844..18c77f7c 100644 --- a/src/epggrab/module/opentv.c +++ b/src/epggrab/module/opentv.c @@ -341,7 +341,7 @@ static int _opentv_parse_event_section ( opentv_module_t *mod, opentv_status_t *sta, uint8_t *buf, int len, int type ) { - int i, cid, update, save = 0; + int i, cid, save = 0; time_t mjd; char *uri; epggrab_channel_t *ec; @@ -381,11 +381,10 @@ static int _opentv_parse_event_section /* Find episode */ if (ebc) { - update = epg_broadcast_set_grabber(ebc, (epggrab_module_t*)mod, &save); - ee = NULL; + ee = NULL; /* Find episode */ - if ((update && (ev.type & OPENTV_SUMMARY)) || !ebc->episode) { + if (ev.type & OPENTV_SUMMARY || !ebc->episode) { uri = epg_hash(ev.title, ev.summary, ev.desc); if (uri) { ee = epg_episode_find_by_uri(uri, 1, &save); @@ -393,36 +392,33 @@ static int _opentv_parse_event_section } } - /* Copy existing title */ - if (!ev.title && ebc->episode && ebc->episode->title) - ev.title = strdup(ebc->episode->title); - /* Use existing */ - if (!ee) - ee = ebc->episode; - else if (update || !ebc->episode) - save |= epg_broadcast_set_episode(ebc, ee); + if (!ee) ee = ebc->episode; /* Update */ if (ee) { - update = epg_episode_set_grabber(ee, (epggrab_module_t*)mod, &save); - - if (ev.title && (update || !ee->title)) + if (!ev.title && ebc->episode) + save |= epg_episode_set_title(ee, ebc->episode->title); + else if (ev.title) save |= epg_episode_set_title(ee, ev.title); - if (ev.summary && (update || !ee->summary)) + if (ev.summary) save |= epg_episode_set_summary(ee, ev.summary); - if (ev.desc && (update || !ee->description)) + if (ev.desc) save |= epg_episode_set_description(ee, ev.desc); - if (ev.cat && (update || !LIST_FIRST(&ee->genre))) { + if (ev.cat) { epg_genre_list_t *egl = calloc(1, sizeof(epg_genre_list_t)); epg_genre_list_add_by_eit(egl, ev.cat); save |= epg_episode_set_genre(ee, egl); epg_genre_list_destroy(egl); } - if (ev.series && (update || !ee->season)) { + // Note: don't override the season (since the ID is channel specific + // it'll keep changing! + if (ev.series && !ee->season) { es = _opentv_find_season(mod, cid, ev.series); if (es) save |= epg_episode_set_season(ee, es); } + + save |= epg_broadcast_set_episode(ebc, ee); } } From 407683324d3f62a2c75b9869766a765c2440048f Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Wed, 11 Jul 2012 10:43:14 +0100 Subject: [PATCH 8/9] Updated grabber modules to new EPG api. --- src/epggrab/module/eit.c | 36 +++++++-------- src/epggrab/module/opentv.c | 15 +++--- src/epggrab/module/pyepg.c | 91 ++++++++++++++++++++----------------- src/epggrab/module/xmltv.c | 85 +++++++++++++++++++--------------- src/epggrab/private.h | 3 +- 5 files changed, 126 insertions(+), 104 deletions(-) diff --git a/src/epggrab/module/eit.c b/src/epggrab/module/eit.c index 428664ab..9bdc9e43 100644 --- a/src/epggrab/module/eit.c +++ b/src/epggrab/module/eit.c @@ -145,7 +145,7 @@ static int _eit_callback ( th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len, uint8_t tableid, void *opaque ) { - epggrab_module_ota_t *mod = opaque; + epggrab_module_t *mod = opaque; epggrab_ota_mux_t *ota; th_dvb_adapter_t *tda; service_t *svc; @@ -168,7 +168,7 @@ static int _eit_callback return -1; /* Get OTA */ - ota = epggrab_ota_find(mod, tdmi); + ota = epggrab_ota_find((epggrab_module_ota_t*)mod, tdmi); if (!ota || !ota->status) return 0; sta = ota->status; @@ -364,11 +364,11 @@ static int _eit_callback /* Metadata */ if ( save2 ) { - save |= epg_broadcast_set_is_hd(ebc, hd); - save |= epg_broadcast_set_is_widescreen(ebc, ws); - save |= epg_broadcast_set_is_audio_desc(ebc, ad); - save |= epg_broadcast_set_is_subtitled(ebc, st); - save |= epg_broadcast_set_is_deafsigned(ebc, ds); + save |= epg_broadcast_set_is_hd(ebc, hd, mod); + save |= epg_broadcast_set_is_widescreen(ebc, ws, mod); + save |= epg_broadcast_set_is_audio_desc(ebc, ad, mod); + save |= epg_broadcast_set_is_subtitled(ebc, st, mod); + save |= epg_broadcast_set_is_deafsigned(ebc, ds, mod); } /* Create episode */ @@ -378,7 +378,7 @@ static int _eit_callback uri = epg_hash(title, summary, desc); if (uri) { if ((ee = epg_episode_find_by_uri(uri, 1, &save2))) - save |= epg_broadcast_set_episode(ebc, ee); + save |= epg_broadcast_set_episode(ebc, ee, mod); free(uri); } } @@ -386,18 +386,18 @@ static int _eit_callback /* Episode data */ if (ee) { - save |= epg_episode_set_is_bw(ee, bw); - if ( !ee->title && *title ) - save |= epg_episode_set_title(ee, title); - if ( !ee->summary && *summary ) - save |= epg_episode_set_summary(ee, summary); - if ( !ee->description && *desc ) - save |= epg_episode_set_description(ee, desc); - if ( !LIST_FIRST(&ee->genre) && egl ) - save |= epg_episode_set_genre(ee, egl); + save |= epg_episode_set_is_bw(ee, bw, mod); + if ( *title ) + save |= epg_episode_set_title(ee, title, mod); + if ( *summary ) + save |= epg_episode_set_summary(ee, summary, mod); + if ( *desc ) + save |= epg_episode_set_description(ee, desc, mod); + if ( egl ) + save |= epg_episode_set_genre(ee, egl, mod); #if TODO_ADD_EXTRA if ( extra ) - save |= epg_episode_set_extra(ee, extra); + save |= epg_episode_set_extra(ee, extra, mod); #endif } diff --git a/src/epggrab/module/opentv.c b/src/epggrab/module/opentv.c index 18c77f7c..a3cf12bf 100644 --- a/src/epggrab/module/opentv.c +++ b/src/epggrab/module/opentv.c @@ -349,6 +349,7 @@ static int _opentv_parse_event_section epg_episode_t *ee; epg_season_t *es; opentv_event_t ev; + epggrab_module_t *src = (epggrab_module_t*)mod; /* Channel */ cid = ((int)buf[0] << 8) | buf[1]; @@ -398,27 +399,27 @@ static int _opentv_parse_event_section /* Update */ if (ee) { if (!ev.title && ebc->episode) - save |= epg_episode_set_title(ee, ebc->episode->title); + save |= epg_episode_set_title(ee, ebc->episode->title, src); else if (ev.title) - save |= epg_episode_set_title(ee, ev.title); + save |= epg_episode_set_title(ee, ev.title, src); if (ev.summary) - save |= epg_episode_set_summary(ee, ev.summary); + save |= epg_episode_set_summary(ee, ev.summary, src); if (ev.desc) - save |= epg_episode_set_description(ee, ev.desc); + save |= epg_episode_set_description(ee, ev.desc, src); if (ev.cat) { epg_genre_list_t *egl = calloc(1, sizeof(epg_genre_list_t)); epg_genre_list_add_by_eit(egl, ev.cat); - save |= epg_episode_set_genre(ee, egl); + save |= epg_episode_set_genre(ee, egl, src); epg_genre_list_destroy(egl); } // Note: don't override the season (since the ID is channel specific // it'll keep changing! if (ev.series && !ee->season) { es = _opentv_find_season(mod, cid, ev.series); - if (es) save |= epg_episode_set_season(ee, es); + if (es) save |= epg_episode_set_season(ee, es, src); } - save |= epg_broadcast_set_episode(ebc, ee); + save |= epg_broadcast_set_episode(ebc, ee, src); } } diff --git a/src/epggrab/module/pyepg.c b/src/epggrab/module/pyepg.c index 3f0679a4..6af08edd 100644 --- a/src/epggrab/module/pyepg.c +++ b/src/epggrab/module/pyepg.c @@ -71,7 +71,8 @@ static epg_genre_list_t return egl; } -static int _pyepg_parse_channel ( htsmsg_t *data, epggrab_stats_t *stats ) +static int _pyepg_parse_channel + ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats ) { int save = 0; epggrab_channel_t *ch; @@ -105,7 +106,8 @@ static int _pyepg_parse_channel ( htsmsg_t *data, epggrab_stats_t *stats ) return save; } -static int _pyepg_parse_brand ( htsmsg_t *data, epggrab_stats_t *stats ) +static int _pyepg_parse_brand + ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats ) { int save = 0; htsmsg_t *attr, *tags; @@ -126,24 +128,24 @@ static int _pyepg_parse_brand ( htsmsg_t *data, epggrab_stats_t *stats ) /* Set title */ if ((str = htsmsg_xml_get_cdata_str(tags, "title"))) { - save |= epg_brand_set_title(brand, str); + save |= epg_brand_set_title(brand, str, mod); } /* Set summary */ if ((str = htsmsg_xml_get_cdata_str(tags, "summary"))) { - save |= epg_brand_set_summary(brand, str); + save |= epg_brand_set_summary(brand, str, mod); } /* Set image */ if ((str = htsmsg_xml_get_cdata_str(tags, "image"))) { - save |= epg_brand_set_image(brand, str); + save |= epg_brand_set_image(brand, str, mod); } else if ((str = htsmsg_xml_get_cdata_str(tags, "thumb"))) { - save |= epg_brand_set_image(brand, str); + save |= epg_brand_set_image(brand, str, mod); } /* Set season count */ if (htsmsg_xml_get_cdata_u32(tags, "series-count", &u32) == 0) { - save |= epg_brand_set_season_count(brand, u32); + save |= epg_brand_set_season_count(brand, u32, mod); } if (save) stats->brands.modified++; @@ -151,7 +153,8 @@ static int _pyepg_parse_brand ( htsmsg_t *data, epggrab_stats_t *stats ) return save; } -static int _pyepg_parse_season ( htsmsg_t *data, epggrab_stats_t *stats ) +static int _pyepg_parse_season + ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats ) { int save = 0; htsmsg_t *attr, *tags; @@ -174,30 +177,30 @@ static int _pyepg_parse_season ( htsmsg_t *data, epggrab_stats_t *stats ) /* Set brand */ if ((str = htsmsg_get_str(attr, "brand"))) { if ((brand = epg_brand_find_by_uri(str, 0, NULL))) { - save |= epg_season_set_brand(season, brand, 1); + save |= epg_season_set_brand(season, brand, mod); } } /* Set summary */ if ((str = htsmsg_xml_get_cdata_str(tags, "summary"))) { - save |= epg_season_set_summary(season, str); + save |= epg_season_set_summary(season, str, mod); } /* Set image */ if ((str = htsmsg_xml_get_cdata_str(tags, "image"))) { - save |= epg_season_set_image(season, str); + save |= epg_season_set_image(season, str, mod); } else if ((str = htsmsg_xml_get_cdata_str(tags, "thumb"))) { - save |= epg_season_set_image(season, str); + save |= epg_season_set_image(season, str, mod); } /* Set season number */ if (htsmsg_xml_get_cdata_u32(tags, "number", &u32) == 0) { - save |= epg_season_set_number(season, u32); + save |= epg_season_set_number(season, u32, mod); } /* Set episode count */ if (htsmsg_xml_get_cdata_u32(tags, "episode-count", &u32) == 0) { - save |= epg_season_set_episode_count(season, u32); + save |= epg_season_set_episode_count(season, u32, mod); } if(save) stats->seasons.modified++; @@ -205,7 +208,8 @@ static int _pyepg_parse_season ( htsmsg_t *data, epggrab_stats_t *stats ) return save; } -static int _pyepg_parse_episode ( htsmsg_t *data, epggrab_stats_t *stats ) +static int _pyepg_parse_episode + ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats ) { int save = 0; htsmsg_t *attr, *tags; @@ -230,56 +234,56 @@ static int _pyepg_parse_episode ( htsmsg_t *data, epggrab_stats_t *stats ) /* Set season */ if ((str = htsmsg_get_str(attr, "series"))) { if ((season = epg_season_find_by_uri(str, 0, NULL))) { - save |= epg_episode_set_season(episode, season); + save |= epg_episode_set_season(episode, season, mod); } } /* Set brand */ if ((str = htsmsg_get_str(attr, "brand"))) { if ((brand = epg_brand_find_by_uri(str, 0, NULL))) { - save |= epg_episode_set_brand(episode, brand); + save |= epg_episode_set_brand(episode, brand, mod); } } /* Set title/subtitle */ if ((str = htsmsg_xml_get_cdata_str(tags, "title"))) { - save |= epg_episode_set_title(episode, str); + save |= epg_episode_set_title(episode, str, mod); } if ((str = htsmsg_xml_get_cdata_str(tags, "subtitle"))) { - save |= epg_episode_set_subtitle(episode, str); + save |= epg_episode_set_subtitle(episode, str, mod); } /* Set summary */ if ((str = htsmsg_xml_get_cdata_str(tags, "summary"))) { - save |= epg_episode_set_summary(episode, str); + save |= epg_episode_set_summary(episode, str, mod); } /* Number */ if (htsmsg_xml_get_cdata_u32(tags, "number", &u32) == 0) { - save |= epg_episode_set_number(episode, u32); + save |= epg_episode_set_number(episode, u32, mod); } if (!htsmsg_xml_get_cdata_u32(tags, "part-number", &pn)) { pc = 0; htsmsg_xml_get_cdata_u32(tags, "part-count", &pc); - save |= epg_episode_set_part(episode, pn, pc); + save |= epg_episode_set_part(episode, pn, pc, mod); } /* Set image */ if ((str = htsmsg_xml_get_cdata_str(tags, "image"))) { - save |= epg_episode_set_image(episode, str); + save |= epg_episode_set_image(episode, str, mod); } else if ((str = htsmsg_xml_get_cdata_str(tags, "thumb"))) { - save |= epg_episode_set_image(episode, str); + save |= epg_episode_set_image(episode, str, mod); } /* Genre */ if ((egl = _pyepg_parse_genre(tags))) { - save |= epg_episode_set_genre(episode, egl); + save |= epg_episode_set_genre(episode, egl, mod); epg_genre_list_destroy(egl); } /* Content */ if ((htsmsg_get_map(tags, "blackandwhite"))) - save |= epg_episode_set_is_bw(episode, 1); + save |= epg_episode_set_is_bw(episode, 1, mod); if (save) stats->episodes.modified++; @@ -287,7 +291,8 @@ static int _pyepg_parse_episode ( htsmsg_t *data, epggrab_stats_t *stats ) } static int _pyepg_parse_broadcast - ( htsmsg_t *data, channel_t *channel, epggrab_stats_t *stats ) + ( epggrab_module_t *mod, htsmsg_t *data, channel_t *channel, + epggrab_stats_t *stats ) { int save = 0; htsmsg_t *attr, *tags; @@ -320,31 +325,32 @@ static int _pyepg_parse_broadcast if ( save ) stats->broadcasts.created++; /* Set episode */ - save |= epg_broadcast_set_episode(broadcast, episode); + save |= epg_broadcast_set_episode(broadcast, episode, mod); /* Quality */ u32 = htsmsg_get_map(tags, "hd") ? 1 : 0; - save |= epg_broadcast_set_is_hd(broadcast, u32); + save |= epg_broadcast_set_is_hd(broadcast, u32, mod); u32 = htsmsg_get_map(tags, "widescreen") ? 1 : 0; - save |= epg_broadcast_set_is_widescreen(broadcast, u32); + save |= epg_broadcast_set_is_widescreen(broadcast, u32, mod); // TODO: lines, aspect /* Accessibility */ // Note: reuse XMLTV parse code as this is the same - xmltv_parse_accessibility(broadcast, tags); + xmltv_parse_accessibility(mod, broadcast, tags); /* New/Repeat */ u32 = htsmsg_get_map(tags, "new") || htsmsg_get_map(tags, "premiere"); - save |= epg_broadcast_set_is_new(broadcast, u32); + save |= epg_broadcast_set_is_new(broadcast, u32, mod); u32 = htsmsg_get_map(tags, "repeat") ? 1 : 0; - save |= epg_broadcast_set_is_repeat(broadcast, u32); + save |= epg_broadcast_set_is_repeat(broadcast, u32, mod); if (save) stats->broadcasts.modified++; return save; } -static int _pyepg_parse_schedule ( htsmsg_t *data, epggrab_stats_t *stats ) +static int _pyepg_parse_schedule + ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats ) { int save = 0; htsmsg_t *attr, *tags; @@ -362,7 +368,7 @@ static int _pyepg_parse_schedule ( htsmsg_t *data, epggrab_stats_t *stats ) HTSMSG_FOREACH(f, tags) { if (strcmp(f->hmf_name, "broadcast") == 0) { - save |= _pyepg_parse_broadcast(htsmsg_get_map_by_field(f), + save |= _pyepg_parse_broadcast(mod, htsmsg_get_map_by_field(f), ec->channel, stats); } } @@ -370,7 +376,8 @@ static int _pyepg_parse_schedule ( htsmsg_t *data, epggrab_stats_t *stats ) return save; } -static int _pyepg_parse_epg ( htsmsg_t *data, epggrab_stats_t *stats ) +static int _pyepg_parse_epg + ( epggrab_module_t *mod, htsmsg_t *data, epggrab_stats_t *stats ) { int save = 0; htsmsg_t *tags; @@ -380,15 +387,15 @@ static int _pyepg_parse_epg ( htsmsg_t *data, epggrab_stats_t *stats ) HTSMSG_FOREACH(f, tags) { if (strcmp(f->hmf_name, "channel") == 0 ) { - save |= _pyepg_parse_channel(htsmsg_get_map_by_field(f), stats); + save |= _pyepg_parse_channel(mod, htsmsg_get_map_by_field(f), stats); } else if (strcmp(f->hmf_name, "brand") == 0 ) { - save |= _pyepg_parse_brand(htsmsg_get_map_by_field(f), stats); + save |= _pyepg_parse_brand(mod, htsmsg_get_map_by_field(f), stats); } else if (strcmp(f->hmf_name, "series") == 0 ) { - save |= _pyepg_parse_season(htsmsg_get_map_by_field(f), stats); + save |= _pyepg_parse_season(mod, htsmsg_get_map_by_field(f), stats); } else if (strcmp(f->hmf_name, "episode") == 0 ) { - save |= _pyepg_parse_episode(htsmsg_get_map_by_field(f), stats); + save |= _pyepg_parse_episode(mod, htsmsg_get_map_by_field(f), stats); } else if (strcmp(f->hmf_name, "schedule") == 0 ) { - save |= _pyepg_parse_schedule(htsmsg_get_map_by_field(f), stats); + save |= _pyepg_parse_schedule(mod, htsmsg_get_map_by_field(f), stats); } } @@ -404,7 +411,7 @@ static int _pyepg_parse /* PyEPG format */ if ((epg = htsmsg_get_map(tags, "epg")) != NULL) - return _pyepg_parse_epg(epg, stats); + return _pyepg_parse_epg(mod, epg, stats); return 0; } diff --git a/src/epggrab/module/xmltv.c b/src/epggrab/module/xmltv.c index 774ed73d..983f78bb 100644 --- a/src/epggrab/module/xmltv.c +++ b/src/epggrab/module/xmltv.c @@ -214,7 +214,9 @@ get_episode_info * job */ static int -parse_vid_quality ( epg_broadcast_t *ebc, epg_episode_t *ee, htsmsg_t *m ) +parse_vid_quality + ( epggrab_module_t *mod, epg_broadcast_t *ebc, epg_episode_t *ee, + htsmsg_t *m ) { int save = 0; int hd = 0, lines = 0, aspect = 0; @@ -222,7 +224,7 @@ parse_vid_quality ( epg_broadcast_t *ebc, epg_episode_t *ee, htsmsg_t *m ) if (!ebc || !m) return 0; if ((str = htsmsg_xml_get_cdata_str(m, "colour"))) - save |= epg_episode_set_is_bw(ee, strcmp(str, "no") ? 0 : 1); + save |= epg_episode_set_is_bw(ee, strcmp(str, "no") ? 0 : 1, mod); if ((str = htsmsg_xml_get_cdata_str(m, "quality"))) { if (strstr(str, "HD")) { hd = 1; @@ -248,13 +250,13 @@ parse_vid_quality ( epg_broadcast_t *ebc, epg_episode_t *ee, htsmsg_t *m ) aspect = (100 * w) / h; } } - save |= epg_broadcast_set_is_hd(ebc, hd); + save |= epg_broadcast_set_is_hd(ebc, hd, mod); if (aspect) { - save |= epg_broadcast_set_is_widescreen(ebc, hd || aspect > 137); - save |= epg_broadcast_set_aspect(ebc, aspect); + save |= epg_broadcast_set_is_widescreen(ebc, hd || aspect > 137, mod); + save |= epg_broadcast_set_aspect(ebc, aspect, mod); } if (lines) - save |= epg_broadcast_set_lines(ebc, lines); + save |= epg_broadcast_set_lines(ebc, lines, mod); return save; } @@ -263,7 +265,8 @@ parse_vid_quality ( epg_broadcast_t *ebc, epg_episode_t *ee, htsmsg_t *m ) * Parse accessibility data */ int -xmltv_parse_accessibility ( epg_broadcast_t *ebc, htsmsg_t *m ) +xmltv_parse_accessibility + ( epggrab_module_t *mod, epg_broadcast_t *ebc, htsmsg_t *m ) { int save = 0; htsmsg_t *tag; @@ -275,12 +278,12 @@ xmltv_parse_accessibility ( epg_broadcast_t *ebc, htsmsg_t *m ) if ((tag = htsmsg_get_map_by_field(f))) { str = htsmsg_xml_get_attr_str(tag, "type"); if (str && !strcmp(str, "teletext")) - save |= epg_broadcast_set_is_subtitled(ebc, 1); + save |= epg_broadcast_set_is_subtitled(ebc, 1, mod); else if (str && !strcmp(str, "deaf-signed")) - save |= epg_broadcast_set_is_deafsigned(ebc, 1); + save |= epg_broadcast_set_is_deafsigned(ebc, 1, mod); } } else if (!strcmp(f->hmf_name, "audio-described")) { - save |= epg_broadcast_set_is_audio_desc(ebc, 1); + save |= epg_broadcast_set_is_audio_desc(ebc, 1, mod); } } return save; @@ -307,9 +310,9 @@ static epg_genre_list_t /** * Parse tags inside of a programme */ -static int -_xmltv_parse_programme_tags(channel_t *ch, htsmsg_t *tags, - time_t start, time_t stop, epggrab_stats_t *stats) +static int _xmltv_parse_programme_tags + (epggrab_module_t *mod, channel_t *ch, htsmsg_t *tags, + time_t start, time_t stop, epggrab_stats_t *stats) { int save = 0, save2 = 0; epg_episode_t *ee; @@ -325,24 +328,33 @@ _xmltv_parse_programme_tags(channel_t *ch, htsmsg_t *tags, /* Ignore */ if (!title) return 0; - /* Build episode */ - uri = md5sum(desc ?: title); + /* + * Episode + */ + + uri = epg_hash(title, NULL, desc); ee = epg_episode_find_by_uri(uri, 1, &save); free(uri); if (!ee) return 0; stats->episodes.total++; if (save) stats->episodes.created++; - if (title) save |= epg_episode_set_title(ee, title); - if (desc) save |= epg_episode_set_description(ee, desc); + if (title) + save |= epg_episode_set_title(ee, title, mod); + if (desc) + save |= epg_episode_set_description(ee, desc, mod); if ((egl = _xmltv_parse_categories(tags))) { - save |= epg_episode_set_genre(ee, egl); + save |= epg_episode_set_genre(ee, egl, mod); epg_genre_list_destroy(egl); } - if (pn) save |= epg_episode_set_part(ee, pn, pc); - if (en) save |= epg_episode_set_number(ee, en); + if (pn) save |= epg_episode_set_part(ee, pn, pc, mod); + if (en) save |= epg_episode_set_number(ee, en, mod); if (save) stats->episodes.modified++; + /* + * Broadcast + */ + // TODO: need to handle certification and ratings // TODO: need to handle season numbering! // TODO: need to handle onscreen numbering @@ -353,20 +365,20 @@ _xmltv_parse_programme_tags(channel_t *ch, htsmsg_t *tags, if ( ebc ) { stats->broadcasts.total++; if (save2) stats->broadcasts.created++; - save2 |= epg_broadcast_set_episode(ebc, ee); + save2 |= epg_broadcast_set_episode(ebc, ee, mod); /* Quality metadata */ - save2 |= parse_vid_quality(ebc, ee, htsmsg_get_map(tags, "video")); + save2 |= parse_vid_quality(mod, ebc, ee, htsmsg_get_map(tags, "video")); /* Accessibility */ - save2 |= xmltv_parse_accessibility(ebc, tags); + save2 |= xmltv_parse_accessibility(mod, ebc, tags); /* Misc */ if (htsmsg_get_map(tags, "previously-shown")) - save |= epg_broadcast_set_is_repeat(ebc, 1); + save |= epg_broadcast_set_is_repeat(ebc, 1, mod); else if (htsmsg_get_map(tags, "premiere") || htsmsg_get_map(tags, "new")) - save |= epg_broadcast_set_is_new(ebc, 1); + save |= epg_broadcast_set_is_new(ebc, 1, mod); /* Stats */ if (save2) stats->broadcasts.modified++; @@ -378,8 +390,8 @@ _xmltv_parse_programme_tags(channel_t *ch, htsmsg_t *tags, /** * Parse a tag from xmltv */ -static int -_xmltv_parse_programme(htsmsg_t *body, epggrab_stats_t *stats) +static int _xmltv_parse_programme + (epggrab_module_t *mod, htsmsg_t *body, epggrab_stats_t *stats) { int save = 0; htsmsg_t *attribs, *tags; @@ -397,19 +409,20 @@ _xmltv_parse_programme(htsmsg_t *body, epggrab_stats_t *stats) if((s = htsmsg_get_str(attribs, "start")) == NULL) return 0; start = _xmltv_str2time(s); if((s = htsmsg_get_str(attribs, "stop")) == NULL) return 0; - stop = _xmltv_str2time(s); + stop = _xmltv_str2time(s); if(stop <= start || stop < dispatch_clock) return 0; - save |= _xmltv_parse_programme_tags(ch->channel, tags, start, stop, stats); + save |= _xmltv_parse_programme_tags(mod, ch->channel, tags, + start, stop, stats); return save; } /** * Parse a tag from xmltv */ -static int -_xmltv_parse_channel(htsmsg_t *body, epggrab_stats_t *stats) +static int _xmltv_parse_channel + (epggrab_module_t *mod, htsmsg_t *body, epggrab_stats_t *stats) { int save =0; htsmsg_t *attribs, *tags, *subtag; @@ -444,8 +457,8 @@ _xmltv_parse_channel(htsmsg_t *body, epggrab_stats_t *stats) /** * */ -static int -_xmltv_parse_tv(htsmsg_t *body, epggrab_stats_t *stats) +static int _xmltv_parse_tv + (epggrab_module_t *mod, htsmsg_t *body, epggrab_stats_t *stats) { int save = 0; htsmsg_t *tags; @@ -456,9 +469,9 @@ _xmltv_parse_tv(htsmsg_t *body, epggrab_stats_t *stats) HTSMSG_FOREACH(f, tags) { if(!strcmp(f->hmf_name, "channel")) { - save |= _xmltv_parse_channel(htsmsg_get_map_by_field(f), stats); + save |= _xmltv_parse_channel(mod, htsmsg_get_map_by_field(f), stats); } else if(!strcmp(f->hmf_name, "programme")) { - save |= _xmltv_parse_programme(htsmsg_get_map_by_field(f), stats); + save |= _xmltv_parse_programme(mod, htsmsg_get_map_by_field(f), stats); } } return save; @@ -475,7 +488,7 @@ static int _xmltv_parse if((tv = htsmsg_get_map(tags, "tv")) == NULL) return 0; - return _xmltv_parse_tv(tv, stats); + return _xmltv_parse_tv(mod, tv, stats); } /* ************************************************************************ diff --git a/src/epggrab/private.h b/src/epggrab/private.h index e1abe0da..6c453753 100644 --- a/src/epggrab/private.h +++ b/src/epggrab/private.h @@ -155,6 +155,7 @@ void xmltv_init ( void ); void xmltv_load ( void ); /* Note: this is reused by pyepg since they share a common format */ -int xmltv_parse_accessibility ( epg_broadcast_t *ebc, htsmsg_t *m ); +int xmltv_parse_accessibility + ( epggrab_module_t *mod, epg_broadcast_t *ebc, htsmsg_t *m ); #endif /* __EPGGRAB_PRIVATE_H__ */ From 9277cac2c4f8dcd7e13246f71dd5f5bef5f7c2c1 Mon Sep 17 00:00:00 2001 From: Adam Sutton Date: Wed, 11 Jul 2012 11:12:13 +0100 Subject: [PATCH 9/9] Correct stupid mistake in setting object grabber. --- src/epg.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/epg.c b/src/epg.c index 35583693..ca72334b 100644 --- a/src/epg.c +++ b/src/epg.c @@ -233,7 +233,8 @@ 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 ) { + if ( !eo->grabber || + ((eo->grabber != grab) && (grab->priority > eo->grabber->priority)) ) { eo->grabber = grab; } return grab == eo->grabber;