void deleteOldfileEvents(const char *epgdir)
{
std::string indexname = std::string(epgdir) + "/index.xml";
xmlDocPtr filter_parser = parseXmlFile(indexname.c_str());
std::string filename;
std::string file;
if (filter_parser != NULL)
{
xmlNodePtr filter = xmlDocGetRootElement(filter_parser);
filter = xmlChildrenNode(filter);
while (filter) {
const char * name = xmlGetAttribute(filter, "name");
if(name){
filename=name;
file = epgdir;
file +="/";
file +=filename;
unlink(file.c_str());
filter = xmlNextNode(filter);
}
}
xmlFreeDoc(filter_parser);
}
}
void readDVBTimeFilter(void)
{
xmlDocPtr filter_parser = parseXmlFile(dvbtime_filter_dir.c_str());
t_original_network_id onid = 0;
t_transport_stream_id tsid = 0;
t_service_id sid = 0;
if (filter_parser != NULL)
{
dprintf("Reading DVBTimeFilters\n");
xmlNodePtr filter = xmlDocGetRootElement(filter_parser);
filter = xmlChildrenNode(filter);
while (filter) {
onid = xmlGetNumericAttribute(filter, "onid", 16);
tsid = xmlGetNumericAttribute(filter, "tsid", 16);
sid = xmlGetNumericAttribute(filter, "serviceID", 16);
addNoDVBTimelist(onid, tsid, sid);
filter = xmlNextNode(filter);
}
xmlFreeDoc(filter_parser);
}
else
{
dvb_time_update = true;
}
}
bool readEPGFilter(void)
{
xmlDocPtr filter_parser = parseXmlFile(epg_filter_dir.c_str());
t_original_network_id onid = 0;
t_transport_stream_id tsid = 0;
t_service_id sid = 0;
if (filter_parser != NULL)
{
dprintf("Reading EPGFilters\n");
xmlNodePtr filter = xmlDocGetRootElement(filter_parser);
if (xmlGetNumericAttribute(filter, "is_whitelist", 10) == 1)
epg_filter_is_whitelist = true;
if (xmlGetNumericAttribute(filter, "except_current_next", 10) == 1)
epg_filter_except_current_next = true;
filter = xmlChildrenNode(filter);
while (filter) {
onid = xmlGetNumericAttribute(filter, "onid", 16);
tsid = xmlGetNumericAttribute(filter, "tsid", 16);
sid = xmlGetNumericAttribute(filter, "serviceID", 16);
if (xmlGetNumericAttribute(filter, "blacklist", 10) == 1)
addBlacklist(onid, tsid, sid);
else
addEPGFilter(onid, tsid, sid);
filter = xmlNextNode(filter);
}
}
xmlFreeDoc(filter_parser);
return (CurrentEPGFilter != NULL);
}
void *insertEventsfromFile(void * data)
{
set_threadname(__func__);
reader_ready=false;
std::string indexname;
std::string filename;
std::string epgname;
xmlNodePtr eventfile;
int ev_count = 0;
if (!data) {
reader_ready = true;
pthread_exit(NULL);
}
std::string epg_dir = (char *) data;
indexname = epg_dir + "index.xml";
time_t now = time_monotonic_ms();
xmlDocPtr index_parser = parseXmlFile(indexname.c_str());
if (index_parser == NULL) {
readEventsFromDir(epg_dir, ev_count);
printf("[sectionsd] Reading Information finished after %ld milliseconds (%d events)\n",
time_monotonic_ms()-now, ev_count);
reader_ready = true;
pthread_exit(NULL);
}
printdate_ms(stdout);
printf("[sectionsd] Reading Information from file %s:\n", indexname.c_str());
eventfile = xmlDocGetRootElement(index_parser);
eventfile = xmlChildrenNode(eventfile);
while (eventfile) {
const char * name = xmlGetAttribute(eventfile, "name");
if(name)
filename=name;
epgname = epg_dir + filename;
readEventsFromFile(epgname, ev_count);
eventfile = xmlNextNode(eventfile);
}
xmlFreeDoc(index_parser);
printdate_ms(stdout);
printf("[sectionsd] Reading Information finished after %ld milliseconds (%d events)\n",
time_monotonic_ms()-now, ev_count);
reader_ready = true;
pthread_exit(NULL);
}
//returns items for selectable timezones
CMenuOptionStringChooser* COsdLangSetup::getTzItems()
{
xmlDocPtr parser = parseXmlFile("/etc/timezone.xml");
CMenuOptionStringChooser* tzSelect = NULL;
if (parser != NULL)
{
tzSelect = new CMenuOptionStringChooser(LOCALE_MAINSETTINGS_TIMEZONE, &g_settings.timezone, true, tzNotifier, CRCInput::RC_green, NULL, true);
tzSelect->setHint("", LOCALE_MENU_HINT_TIMEZONE);
xmlNodePtr search = xmlDocGetRootElement(parser);
search = xmlChildrenNode(search);
bool found = false;
while (search)
{
if (!strcmp(xmlGetName(search), "zone"))
{
const char* zptr = xmlGetAttribute(search, "zone");
std::string zone;
if(zptr)
zone = zptr;
//printf("Timezone: %s -> %s\n", name.c_str(), zone.c_str());
if (access("/usr/share/zoneinfo/" + zone, R_OK))
printf("[neutrino] timezone file '%s' not installed\n", zone.c_str());
else
{
const char* ptr = xmlGetAttribute(search, "name");
if(ptr){
std::string name = ptr;
tzSelect->addOption(name);
found = true;
}
}
}
search = xmlNextNode(search);
}
if (!found)
{
delete tzSelect;
tzSelect = NULL;
}
xmlFreeDoc(parser);
}
return tzSelect;
}
bool CTZChangeNotifier::changeNotify(const neutrino_locale_t, void * Data)
{
bool found = false;
std::string name, zone;
printf("CTZChangeNotifier::changeNotify: %s\n", (char *) Data);
xmlDocPtr parser = parseXmlFile("/etc/timezone.xml");
if (parser != NULL) {
xmlNodePtr search = xmlDocGetRootElement(parser);
search = xmlChildrenNode(search);
while (search) {
if (!strcmp(xmlGetName(search), "zone")) {
const char *nptr = xmlGetAttribute(search, "name");
if(nptr)
name = nptr;
if(g_settings.timezone == name) {
const char *zptr = xmlGetAttribute(search, "zone");
if(zptr)
zone = zptr;
if (!access("/usr/share/zoneinfo/" + zone, R_OK))
found = true;
break;
}
}
search = xmlNextNode(search);
}
xmlFreeDoc(parser);
}
if(found) {
printf("Timezone: %s -> %s\n", name.c_str(), zone.c_str());
std::string cmd = "/usr/share/zoneinfo/" + zone;
printf("symlink %s to /etc/localtime\n", cmd.c_str());
if (unlink("/etc/localtime"))
perror("unlink failed");
if (symlink(cmd.c_str(), "/etc/localtime"))
perror("symlink failed");
#if 0
cmd = ":" + zone;
setenv("TZ", cmd.c_str(), 1);
#endif
tzset();
}
return false;
}
std::vector<UPnPEntry> *CUpnpBrowserGui::decodeResult(std::string result)
{
xmlNodePtr root, node, snode;
std::vector<UPnPEntry> *entries;
xmlDocPtr parser = parseXml(result.c_str(),"UTF-8");
root = xmlDocGetRootElement(parser);
if (!root) {
xmlFreeDoc(parser);
return NULL;
}
entries = new std::vector<UPnPEntry>;
for (node=xmlChildrenNode(root); node; node=xmlNextNode(node))
{
bool isdir;
std::string title, artist = "", album = "", albumArtURI = "", id, children;
const char *type, *p;
if (!strcmp(xmlGetName(node), "container"))
{
std::vector<UPnPResource> resources;
isdir=true;
for (snode=xmlChildrenNode(node); snode; snode=xmlNextNode(snode))
{
type=xmlGetName(snode);
p = strchr(type,':');
if (p)
type=p+1;
if (!strcmp(type,"title"))
{
p=xmlGetData(snode);
if (!p)
p = "";
title=std::string(p);
}
}
p = xmlGetAttribute(node, "id");
if (!p)
p = "";
id=std::string(p);
p = xmlGetAttribute(node, "childCount");
if (!p)
p = "";
children=std::string(p);
UPnPEntry entry={id, isdir, title, artist, album, albumArtURI, children, "", "", resources, -1, CFile::FILE_DIR};
entries->push_back(entry);
}
if (!strcmp(xmlGetName(node), "item"))
{
std::vector<UPnPResource> resources;
int preferred = -1;
std::string protocol, prot, network, mime, additional;
CFile::FileType ftype = CFile::FILE_UNKNOWN;
isdir=false;
for (snode=xmlChildrenNode(node); snode; snode=xmlNextNode(snode))
{
std::string duration, url, size;
unsigned int i;
type=xmlGetName(snode);
p = strchr(type,':');
if (p)
type=p+1;
if (!strcmp(type,"title"))
{
p=xmlGetData(snode);
if (!p)
p = "";
title=std::string(p);
}
else if (!strcmp(type,"artist"))
{
p=xmlGetData(snode);
if (!p)
p = "";
artist=std::string(p);
}
else if (!strcmp(type,"album"))
{
p=xmlGetData(snode);
if (!p)
p = "";
album=std::string(p);
}
else if (!strcmp(type,"albumArtURI"))
{
p=xmlGetData(snode);
if (!p)
p = "";
albumArtURI=std::string(p);
}
else if (!strcmp(type,"res"))
{
p = xmlGetData(snode);
if (!p)
p = "";
url=std::string(p);
p = xmlGetAttribute(snode, "size");
if (!p)
p = "0";
size=std::string(p);
p = xmlGetAttribute(snode, "duration");
if (!p)
p = "";
duration=std::string(p);
p = xmlGetAttribute(snode, "protocolInfo");
if (!p)
p = "";
protocol=std::string(p);
UPnPResource resource = {url, protocol, size, duration};
resources.push_back(resource);
}
int pref=0;
preferred=-1;
for (i=0; i<resources.size(); i++)
{
protocol=resources[i].protocol;
splitProtocol(protocol, prot, network, mime, additional);
if (prot != "http-get")
continue;
if (mime.substr(0,6) == "image/" && pref < 1)
{
preferred=i;
}
if (mime == "image/jpeg" && pref < 1)
{
preferred=i;
pref=1;
}
if (mime == "image/gif" && pref < 2)
{
preferred=i;
pref=2;
}
if (mime == "audio/mpeg" && pref < 3)
{
preferred=i;
pref=3;
ftype = CFile::FILE_MP3;
}
if ((mime == "audio/ogg" || mime == "audio/x-ogg") && pref < 4)
{
ftype = CFile::FILE_OGG;
preferred=i;
pref=4;
}
if (mime == "audio/x-flac" && pref < 5)
{
preferred=i;
pref=5;
ftype = CFile::FILE_FLAC;
}
if (mime == "audio/x-wav" && pref < 6)
{
preferred=i;
pref=6;
ftype = CFile::FILE_WAV;
}
if (mime.substr(0,6) == "video/" && pref < 7)
{
preferred=i;
pref=7;
}
if (mime == "video/x-flv" && pref < 8)
{
preferred=i;
pref=8;
}
if (mime == "video/mp4" && pref < 9)
{
preferred=i;
pref=9;
}
}
}
p = xmlGetAttribute(node, "id");
if (!p)
p = "";
id=std::string(p);
p = xmlGetAttribute(node, "childCount");
if (!p)
p = "";
children=std::string(p);
UPnPEntry entry={id, isdir, title, artist, album, albumArtURI, children, prot, mime, resources, preferred, ftype};
entries->push_back(entry);
}
}
xmlFreeDoc(parser);
return entries;
}
bool readEventsFromFile(std::string &epgname, int &ev_count)
{
xmlDocPtr event_parser = NULL;
xmlNodePtr service;
xmlNodePtr event;
t_original_network_id onid = 0;
t_transport_stream_id tsid = 0;
t_service_id sid = 0;
if (!(event_parser = parseXmlFile(epgname.c_str()))) {
dprintf("unable to open %s for reading\n", epgname.c_str());
return false;
}
service = xmlDocGetRootElement(event_parser);
service = xmlChildrenNode(service);
while (service) {
onid = xmlGetNumericAttribute(service, "original_network_id", 16);
tsid = xmlGetNumericAttribute(service, "transport_stream_id", 16);
sid = xmlGetNumericAttribute(service, "service_id", 16);
event = xmlChildrenNode(service);
while (event) {
SIevent e(onid,tsid,sid,xmlGetNumericAttribute(event, "id", 16));
uint8_t tid = xmlGetNumericAttribute(event, "tid", 16);
std::string contentClassification, userClassification;
if(tid)
e.table_id = tid;
e.table_id |= 0x80; /* make sure on-air data has a lower table_id */
xmlNodePtr node;
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "name"))) {
const char *s = xmlGetAttribute(node, "string");
if (s)
e.setName(ZapitTools::UTF8_to_Latin1(xmlGetAttribute(node, "lang")), s);
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "text"))) {
const char *s = xmlGetAttribute(node, "string");
if (s)
e.setText(ZapitTools::UTF8_to_Latin1(xmlGetAttribute(node, "lang")), s);
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "item"))) {
#ifdef USE_ITEM_DESCRIPTION
const char *s = xmlGetAttribute(node, "string");
if (s)
e.item = s;
#endif
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "item_description"))) {
#ifdef USE_ITEM_DESCRIPTION
const char *s = xmlGetAttribute(node, "string");
if (s)
e.itemDescription = s;
#endif
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "extended_text"))) {
const char *l = xmlGetAttribute(node, "lang");
const char *s = xmlGetAttribute(node, "string");
if (l && s)
e.appendExtendedText(ZapitTools::UTF8_to_Latin1(l), s);
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "time"))) {
e.times.insert(SItime(xmlGetNumericAttribute(node, "start_time", 10),
xmlGetNumericAttribute(node, "duration", 10)));
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "content"))) {
const char cl = xmlGetNumericAttribute(node, "class", 16);
contentClassification += cl;
const char cl2 = xmlGetNumericAttribute(node, "user", 16);
userClassification += cl2;
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "component"))) {
SIcomponent c;
c.streamContent = xmlGetNumericAttribute(node, "stream_content", 16);
c.componentType = xmlGetNumericAttribute(node, "type", 16);
c.componentTag = xmlGetNumericAttribute(node, "tag", 16);
const char *s = xmlGetAttribute(node, "text");
if (s)
c.setComponent(s);
//e.components.insert(c);
e.components.push_back(c);
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "parental_rating"))) {
const char *s = xmlGetAttribute(node, "country");
if (s)
#if 0
e.ratings.insert(SIparentalRating(ZapitTools::UTF8_to_Latin1(s),
(unsigned char) xmlGetNumericAttribute(node, "rating", 10)));
#endif
e.ratings.push_back(SIparentalRating(ZapitTools::UTF8_to_Latin1(s),
(unsigned char) xmlGetNumericAttribute(node, "rating", 10)));
node = xmlNextNode(node);
}
node = xmlChildrenNode(event);
while ((node = xmlGetNextOccurence(node, "linkage"))) {
SIlinkage l;
l.linkageType = xmlGetNumericAttribute(node, "type", 16);
l.transportStreamId = xmlGetNumericAttribute(node, "transport_stream_id", 16);
l.originalNetworkId = xmlGetNumericAttribute(node, "original_network_id", 16);
l.serviceId = xmlGetNumericAttribute(node, "service_id", 16);
const char *s = xmlGetAttribute(node, "linkage_descriptor");
if (s)
l.name = s;
e.linkage_descs.insert(e.linkage_descs.end(), l);
node = xmlNextNode(node);
}
if (!contentClassification.empty()) {
#ifdef FULL_CONTENT_CLASSIFICATION
ssize_t off = e.classifications.reserve(2 * contentClassification.size());
if (off > -1)
for (unsigned i = 0; i < contentClassification.size(); i++)
off = e.classifications.set(off, contentClassification.at(i), userClassification.at(i));
#else
e.classifications.content = contentClassification.at(0);
e.classifications.user = userClassification.at(0);
#endif
}
addEvent(e, 0);
ev_count++;
event = xmlNextNode(event);
}
service = xmlNextNode(service);
}
xmlFreeDoc(event_parser);
return true;
}
