mirror of
https://github.com/tuxbox-neutrino/neutrino.git
synced 2025-08-31 09:21:18 +02:00
410 lines
12 KiB
C++
410 lines
12 KiB
C++
//
|
|
// $Id: SIevents.hpp,v 1.29 2008/08/16 19:23:18 seife Exp $
|
|
//
|
|
// classes SIevent and SIevents (dbox-II-project)
|
|
//
|
|
// Homepage: http://dbox2.elxsi.de
|
|
//
|
|
// Copyright (C) 2001 fnbrd (fnbrd@gmx.de)
|
|
//
|
|
// 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
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
//
|
|
#ifndef SIEVENTS_HPP
|
|
#define SIEVENTS_HPP
|
|
|
|
#include <vector>
|
|
#include <map>
|
|
#include <set>
|
|
#include <algorithm>
|
|
#include <string>
|
|
|
|
#include <sectionsdclient/sectionsdtypes.h>
|
|
#include <dvbsi++/event_information_section.h>
|
|
#include "edvbstring.h"
|
|
|
|
class SIlinkage {
|
|
public:
|
|
unsigned char linkageType;
|
|
std::string name;
|
|
t_transport_stream_id transportStreamId;
|
|
t_original_network_id originalNetworkId;
|
|
t_service_id serviceId;
|
|
|
|
SIlinkage(void) {
|
|
linkageType = 0;
|
|
transportStreamId = 0;
|
|
originalNetworkId = 0;
|
|
serviceId = 0;
|
|
}
|
|
|
|
|
|
void dump(void) const {
|
|
printf("Linakge Type: 0x%02hhx\n", linkageType);
|
|
if (name.length())
|
|
printf("Name: %s\n", name.c_str());
|
|
printf("Transport Stream Id: 0x%04hhx\n", transportStreamId);
|
|
printf("Original Network Id: 0x%04hhx\n", originalNetworkId);
|
|
printf("Service Id: 0x%04hhx\n", serviceId);
|
|
}
|
|
|
|
int saveXML(FILE *file) const {
|
|
fprintf(file, "\t\t\t<linkage type=\"%02x\" linkage_descriptor=\"", linkageType);
|
|
saveStringToXMLfile(file, name.c_str());
|
|
fprintf(file, "\" transport_stream_id=\"%04x\" original_network_id=\"%04x\" service_id=\"%04x\" />\n", transportStreamId, originalNetworkId, serviceId);
|
|
// %s, , name.c_str())<0)
|
|
// return 1;
|
|
return 0;
|
|
}
|
|
// Der Operator zum sortieren
|
|
bool operator < (const SIlinkage& l) const {
|
|
return name < l.name;
|
|
}
|
|
bool operator==(const SIlinkage& s) const {
|
|
return (linkageType == s.linkageType) &&
|
|
(transportStreamId == s.transportStreamId) &&
|
|
(originalNetworkId == s.originalNetworkId) &&
|
|
(serviceId == s.serviceId) &&
|
|
(name == s.name);
|
|
}
|
|
bool operator!=(const SIlinkage& s) const {
|
|
return (linkageType != s.linkageType) ||
|
|
(transportStreamId != s.transportStreamId) ||
|
|
(originalNetworkId != s.originalNetworkId) ||
|
|
(serviceId != s.serviceId) ||
|
|
(name != s.name);
|
|
}
|
|
};
|
|
typedef std::vector<class SIlinkage> SIlinkage_descs;
|
|
|
|
// Fuer for_each
|
|
struct printSIlinkage : public std::unary_function<class SIlinkage, void>
|
|
{
|
|
void operator() (const SIlinkage &l) { l.dump();}
|
|
};
|
|
|
|
// Fuer for_each
|
|
struct saveSIlinkageXML : public std::unary_function<class SIlinkage, void>
|
|
{
|
|
FILE *f;
|
|
saveSIlinkageXML(FILE *fi) { f=fi;}
|
|
void operator() (const SIlinkage &l) { l.saveXML(f);}
|
|
};
|
|
|
|
class SIcomponent
|
|
{
|
|
public:
|
|
std::string component;
|
|
unsigned char componentType;
|
|
unsigned char componentTag;
|
|
unsigned char streamContent;
|
|
|
|
SIcomponent(void) {
|
|
streamContent=0;
|
|
componentType=0;
|
|
componentTag=0;
|
|
}
|
|
void dump(void) const {
|
|
if(component.length())
|
|
printf("Component: %s\n", component.c_str());
|
|
printf("Stream Content: 0x%02hhx\n", streamContent);
|
|
printf("Component type: 0x%02hhx\n", componentType);
|
|
printf("Component tag: 0x%02hhx\n", componentTag);
|
|
}
|
|
int saveXML(FILE *file) const {
|
|
fprintf(file, "\t\t\t<component tag=\"%02x\" type=\"%02x\" stream_content=\"%02x\" text=\"", componentTag, componentType, streamContent);
|
|
saveStringToXMLfile(file,component.c_str());
|
|
fprintf(file, "\"/>\n");
|
|
return 0;
|
|
}
|
|
// Der Operator zum sortieren
|
|
bool operator < (const SIcomponent& c) const {
|
|
return streamContent < c.streamContent;
|
|
}
|
|
bool operator==(const SIcomponent& c) const {
|
|
return (componentType == c.componentType) &&
|
|
(componentTag == c.componentTag) &&
|
|
(streamContent == c.streamContent) &&
|
|
(component == c.component);
|
|
}
|
|
bool operator!=(const SIcomponent& c) const {
|
|
return (componentType != c.componentType) ||
|
|
(componentTag != c.componentTag) ||
|
|
(streamContent != c.streamContent) ||
|
|
(component != c.component);
|
|
}
|
|
};
|
|
|
|
typedef std::multiset <SIcomponent, std::less<SIcomponent> > SIcomponents;
|
|
|
|
// Fuer for_each
|
|
struct printSIcomponent : public std::unary_function<class SIcomponent, void>
|
|
{
|
|
void operator() (const SIcomponent &c) { c.dump();}
|
|
};
|
|
|
|
// Fuer for_each
|
|
struct saveSIcomponentXML : public std::unary_function<class SIcomponent, void>
|
|
{
|
|
FILE *f;
|
|
saveSIcomponentXML(FILE *fi) { f=fi;}
|
|
void operator() (const SIcomponent &c) { c.saveXML(f);}
|
|
};
|
|
|
|
class SIparentalRating
|
|
{
|
|
public:
|
|
std::string countryCode;
|
|
unsigned char rating; // Bei 1-16 -> Minumim Alter = rating +3
|
|
|
|
SIparentalRating(const std::string &cc, unsigned char rate) {
|
|
rating=rate;
|
|
countryCode=cc;
|
|
}
|
|
|
|
// Der Operator zum sortieren
|
|
bool operator < (const SIparentalRating& c) const {
|
|
return countryCode < c.countryCode;
|
|
}
|
|
void dump(void) const {
|
|
printf("Rating: %s %hhu (+3)\n", countryCode.c_str(), rating);
|
|
}
|
|
int saveXML(FILE *file) const {
|
|
if(fprintf(file, "\t\t\t<parental_rating country=\"%s\" rating=\"%hhu\"/>\n", countryCode.c_str(), rating)<0)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
bool operator==(const SIparentalRating& p) const {
|
|
return (rating == p.rating) &&
|
|
(countryCode == p.countryCode);
|
|
}
|
|
bool operator!=(const SIparentalRating& p) const {
|
|
return (rating != p.rating) ||
|
|
(countryCode != p.countryCode);
|
|
}
|
|
};
|
|
typedef std::set <SIparentalRating, std::less<SIparentalRating> > SIparentalRatings;
|
|
|
|
// Fuer for_each
|
|
struct printSIparentalRating : public std::unary_function<SIparentalRating, void>
|
|
{
|
|
void operator() (const SIparentalRating &r) { r.dump();}
|
|
};
|
|
|
|
// Fuer for_each
|
|
struct saveSIparentalRatingXML : public std::unary_function<SIparentalRating, void>
|
|
{
|
|
FILE *f;
|
|
saveSIparentalRatingXML(FILE *fi) { f=fi;}
|
|
void operator() (const SIparentalRating &r) { r.saveXML(f);}
|
|
};
|
|
|
|
class SItime {
|
|
public:
|
|
time_t startzeit; // lokale Zeit, 0 -> time shifted (cinedoms)
|
|
unsigned dauer; // in Sekunden, 0 -> time shifted (cinedoms)
|
|
|
|
SItime(time_t s, unsigned d) {
|
|
startzeit=s;
|
|
dauer=d; // in Sekunden, 0 -> time shifted (cinedoms)
|
|
}
|
|
|
|
// Der Operator zum sortieren
|
|
bool operator < (const SItime& t) const {
|
|
return startzeit < t.startzeit;
|
|
}
|
|
void dump(void) const {
|
|
printf("Startzeit: %s", ctime(&startzeit));
|
|
printf("Dauer: %02u:%02u:%02u (%umin, %us)\n", dauer/3600, (dauer%3600)/60, dauer%60, dauer/60, dauer);
|
|
}
|
|
int saveXML(FILE *file) const { // saves the time
|
|
fprintf(file, "\t\t\t<time start_time=\"%u\" duration=\"%u\"/>\n", (unsigned int) startzeit, dauer);
|
|
return 0;
|
|
}
|
|
bool operator==(const SItime& t) const {
|
|
return (dauer == t.dauer) &&
|
|
(startzeit == t.startzeit);
|
|
}
|
|
bool operator!=(const SItime& t) const {
|
|
return (dauer != t.dauer) ||
|
|
(startzeit != t.startzeit);
|
|
}
|
|
};
|
|
|
|
typedef std::set <SItime, std::less<SItime> > SItimes;
|
|
|
|
// Fuer for_each
|
|
struct printSItime : public std::unary_function<SItime, void>
|
|
{
|
|
void operator() (const SItime &t) { t.dump();}
|
|
};
|
|
|
|
// Fuer for_each
|
|
struct saveSItimeXML : public std::unary_function<SItime, void>
|
|
{
|
|
FILE *f;
|
|
saveSItimeXML(FILE *fi) { f=fi;}
|
|
void operator() (const SItime &t) { t.saveXML(f);}
|
|
};
|
|
|
|
class SIevent
|
|
{
|
|
private:
|
|
std::map<std::string, std::string> langName;
|
|
std::map<std::string, std::string> langText;
|
|
std::map<std::string, std::string> langExtendedText;
|
|
int running;
|
|
|
|
protected:
|
|
int saveXML0(FILE *f) const;
|
|
int saveXML2(FILE *f) const;
|
|
|
|
public:
|
|
t_service_id service_id;
|
|
t_original_network_id original_network_id;
|
|
t_transport_stream_id transport_stream_id;
|
|
unsigned short eventID;
|
|
time_t vps;
|
|
unsigned char table_id;
|
|
unsigned char version;
|
|
|
|
SIcomponents components;
|
|
SIparentalRatings ratings;
|
|
SIlinkage_descs linkage_descs;
|
|
SItimes times;
|
|
|
|
std::string itemDescription; // Aus dem Extended Descriptor
|
|
std::string item; // Aus dem Extended Descriptor
|
|
std::string contentClassification; // Aus dem Content Descriptor, als String, da mehrere vorkommen koennen
|
|
std::string userClassification; // Aus dem Content Descriptor, als String, da mehrere vorkommen koennen
|
|
|
|
SIevent(const t_original_network_id, const t_transport_stream_id, const t_service_id, const unsigned short);
|
|
SIevent(void) {
|
|
service_id = 0;
|
|
original_network_id = 0;
|
|
transport_stream_id = 0;
|
|
eventID = 0;
|
|
vps = 0;
|
|
table_id = 0xFF; /* 0xFF means "not set" */
|
|
version = 0xFF;
|
|
}
|
|
void parse(Event &event);
|
|
|
|
// Name aus dem Short-Event-Descriptor
|
|
std::string getName() const;
|
|
void setName(const std::string &lang, const std::string &name);
|
|
|
|
// Text aus dem Short-Event-Descriptor
|
|
std::string getText() const;
|
|
void setText(const std::string &lang, const std::string &text);
|
|
|
|
// Aus dem Extended Descriptor
|
|
std::string getExtendedText() const;
|
|
void appendExtendedText(const std::string &lang, const std::string &text);
|
|
void setExtendedText(const std::string &lang, const std::string &text);
|
|
|
|
t_channel_id get_channel_id(void) const {
|
|
return CREATE_CHANNEL_ID;
|
|
}
|
|
|
|
event_id_t uniqueKey(void) const {
|
|
return CREATE_EVENT_ID(CREATE_CHANNEL_ID, eventID);
|
|
}
|
|
int runningStatus(void) const {
|
|
return running;
|
|
}
|
|
// Der Operator zum sortieren
|
|
bool operator < (const SIevent& e) const {
|
|
return uniqueKey()<e.uniqueKey();
|
|
}
|
|
int saveXML(FILE *file) const { // saves the event
|
|
return saveXML0(file) || saveXML2(file);
|
|
}
|
|
int saveXML(FILE *file, const char *serviceName) const; // saves the event
|
|
char getFSK() const;
|
|
|
|
void dump(void) const; // dumps the event to stdout
|
|
void dumpSmall(void) const; // dumps the event to stdout (not all information)
|
|
};
|
|
|
|
typedef std::set <SIevent, std::less<SIevent> > SIevents;
|
|
|
|
// Fuer for_each
|
|
struct printSIevent : public std::unary_function<SIevent, void>
|
|
{
|
|
void operator() (const SIevent &e) { e.dump();}
|
|
};
|
|
|
|
// Fuer for_each
|
|
struct saveSIeventXML : public std::unary_function<SIevent, void>
|
|
{
|
|
FILE *f;
|
|
saveSIeventXML(FILE *fi) { f=fi;}
|
|
void operator() (const SIevent &e) { e.saveXML(f);}
|
|
};
|
|
|
|
#if 0
|
|
// Fuer for_each
|
|
struct saveSIeventXMLwithServiceName : public std::unary_function<SIevent, void>
|
|
{
|
|
FILE *f;
|
|
const SIservices *s;
|
|
saveSIeventXMLwithServiceName(FILE *fi, const SIservices &svs) {f=fi; s=&svs;}
|
|
void operator() (const SIevent &e) {
|
|
SIservices::iterator k=s->find(SIservice(e.service_id, e.original_network_id, e.transport_stream_id));
|
|
if(k!=s->end()) {
|
|
if(k->serviceName.length())
|
|
e.saveXML(f, k->serviceName.c_str());
|
|
}
|
|
else
|
|
e.saveXML(f);
|
|
}
|
|
};
|
|
#endif
|
|
|
|
#if 0
|
|
// Fuer for_each
|
|
struct printSIeventWithService : public std::unary_function<SIevent, void>
|
|
{
|
|
printSIeventWithService(const SIservices &svs) { s=&svs;}
|
|
void operator() (const SIevent &e) {
|
|
SIservices::iterator k=s->find(SIservice(e.service_id, e.original_network_id, e.transport_stream_id));
|
|
if(k!=s->end()) {
|
|
char servicename[50];
|
|
strncpy(servicename, k->serviceName.c_str(), sizeof(servicename)-1);
|
|
servicename[sizeof(servicename)-1]=0;
|
|
removeControlCodes(servicename);
|
|
printf("Service-Name: %s\n", servicename);
|
|
// printf("Provider-Name: %s\n", k->providerName.c_str());
|
|
}
|
|
e.dump();
|
|
// e.dumpSmall();
|
|
printf("\n");
|
|
}
|
|
const SIservices *s;
|
|
};
|
|
|
|
class SIevents : public std::set <SIevent, std::less<SIevent> >
|
|
{
|
|
public:
|
|
// Entfernt anhand der Services alle time shifted events (Service-Typ 0)
|
|
// und sortiert deren Zeiten in die Events mit dem Text ein.
|
|
void mergeAndRemoveTimeShiftedEvents(const SIservices &);
|
|
// Loescht alte Events (aufgrund aktueller Zeit - seconds und Zeit im Event)
|
|
void removeOldEvents(long seconds);
|
|
};
|
|
#endif
|
|
|
|
#endif // SIEVENTS_HPP
|