mirrors/recycled-ni-neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-fork-migrations/recycled-ni-neutrino.git synced 2025-09-15 09:23:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

reformat wiith unix2dos & astyle

Browse Source 
git-svn-id: file:///home/bas/coolstream_public_svn/THIRDPARTY/applications/neutrino-experimental@1495 e54a6e83-5905-42d5-8d5c-058d10e6a962


Origin commit data
------------------
Commit: 7dab3d9e3e
Author: Jacek Jendrzej <overx300@gmail.com>
Date: 2011-05-26 (Thu, 26 May 2011)
This commit is contained in:
Jacek Jendrzej
2011-05-26 20:23:16 +00:00
parent db929afe88
commit 4c8a9a8efb
14 changed files with 10830 additions and 10576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
src/sectionsd/SIevents.cpp
View File

@@ -81,7 +81,7 @@ SIevent::SIevent(const t_original_network_id _original_network_id, const t_trans
eventID = _event_id; eventID = _event_id;
table_id = 0xFF; /* not set */ table_id = 0xFF; /* not set */
version = 0xFF; version = 0xFF;
/* contentClassification = ""; /* contentClassification = "";
userClassification = ""; userClassification = "";
itemDescription = ""; itemDescription = "";
item = ""; item = "";
@@ -212,7 +212,7 @@ int SIevent::saveXML2(FILE *file) const
std::string SIevent::getName() const std::string SIevent::getName() const
{ {
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
std::map<std::string, std::string>::const_iterator it = langName.begin() ; std::map<std::string, std::string>::const_iterator it = langName.begin() ;
if (it != langName.end()) return it->second; if (it != langName.end()) return it->second;
else return(""); else return("");
@@ -228,7 +228,7 @@ void SIevent::setName(const std::string &lang, const std::string &name)
std::string tmp = name; std::string tmp = name;
std::replace(tmp.begin(), tmp.end(), '\n', ' '); std::replace(tmp.begin(), tmp.end(), '\n', ' ');
//printf("setName: lang %s text %s\n", lang.c_str(), name.c_str()); //printf("setName: lang %s text %s\n", lang.c_str(), name.c_str());
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
langName[languangeOFF] = tmp; //name; langName[languangeOFF] = tmp; //name;
} else { } else {
langName[lang] = tmp; //name; langName[lang] = tmp; //name;
@@ -237,7 +237,7 @@ void SIevent::setName(const std::string &lang, const std::string &name)
std::string SIevent::getText() const std::string SIevent::getText() const
{ {
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
std::map<std::string, std::string>::const_iterator it = langText.begin() ; std::map<std::string, std::string>::const_iterator it = langText.begin() ;
if (it != langText.end()) return it->second; if (it != langText.end()) return it->second;
else return(""); else return("");
@@ -251,7 +251,7 @@ std::string SIevent::getText() const
void SIevent::setText(const std::string &lang, const std::string &text) void SIevent::setText(const std::string &lang, const std::string &text)
{ {
//printf("setText: lang %s text %s\n", lang.c_str(), text.c_str()); //printf("setText: lang %s text %s\n", lang.c_str(), text.c_str());
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
langText[languangeOFF] = text; langText[languangeOFF] = text;
} else { } else {
langText[lang] = text; langText[lang] = text;
@@ -260,7 +260,7 @@ void SIevent::setText(const std::string &lang, const std::string &text)
std::string SIevent::getExtendedText() const std::string SIevent::getExtendedText() const
{ {
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
std::map<std::string, std::string>::const_iterator it = langExtendedText.begin() ; std::map<std::string, std::string>::const_iterator it = langExtendedText.begin() ;
if (it != langExtendedText.end()) return it->second; if (it != langExtendedText.end()) return it->second;
else return(""); else return("");
@@ -273,7 +273,7 @@ std::string SIevent::getExtendedText() const
void SIevent::appendExtendedText(const std::string &lang, const std::string &text) void SIevent::appendExtendedText(const std::string &lang, const std::string &text)
{ {
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
langExtendedText[languangeOFF] += text; langExtendedText[languangeOFF] += text;
} else { } else {
langExtendedText[lang] += text; langExtendedText[lang] += text;
@@ -283,7 +283,7 @@ void SIevent::appendExtendedText(const std::string &lang, const std::string &tex
void SIevent::setExtendedText(const std::string &lang, const std::string &text) void SIevent::setExtendedText(const std::string &lang, const std::string &text)
{ {
//printf("setExtendedText: lang %s text %s\n", lang.c_str(), text.c_str()); //printf("setExtendedText: lang %s text %s\n", lang.c_str(), text.c_str());
if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()){ if (CSectionsdClient::LANGUAGE_MODE_OFF == SIlanguage::getMode()) {
langExtendedText[languangeOFF] = text; langExtendedText[languangeOFF] = text;
} else { } else {
langExtendedText[lang] = text; langExtendedText[lang] = text;
@@ -325,12 +325,12 @@ void SIevent::dump(void) const
printf(" 0x%02hhx", userClassification[i]); printf(" 0x%02hhx", userClassification[i]);
printf("\n"); printf("\n");
} }
/* /*
if(startzeit) if(startzeit)
printf("Startzeit: %s", ctime(&startzeit)); printf("Startzeit: %s", ctime(&startzeit));
if(dauer) if(dauer)
printf("Dauer: %02u:%02u:%02u (%umin, %us)\n", dauer/3600, (dauer%3600)/60, dauer%60, dauer/60, dauer); printf("Dauer: %02u:%02u:%02u (%umin, %us)\n", dauer/3600, (dauer%3600)/60, dauer%60, dauer/60, dauer);
*/ */
for_each(times.begin(), times.end(), printSItime()); for_each(times.begin(), times.end(), printSItime());
for_each(components.begin(), components.end(), printSIcomponent()); for_each(components.begin(), components.end(), printSIcomponent());
for_each(ratings.begin(), ratings.end(), printSIparentalRating()); for_each(ratings.begin(), ratings.end(), printSIparentalRating());
@@ -348,12 +348,12 @@ void SIevent::dumpSmall(void) const
for (std::map<std::string, std::string>::const_iterator it = langExtendedText.begin() ; for (std::map<std::string, std::string>::const_iterator it = langExtendedText.begin() ;
it != langExtendedText.end() ; ++it) it != langExtendedText.end() ; ++it)
printf("Extended-Text (%s): %s\n", it->first.c_str(), it->second.c_str()); printf("Extended-Text (%s): %s\n", it->first.c_str(), it->second.c_str());
/* /*
if(startzeit) if(startzeit)
printf("Startzeit: %s", ctime(&startzeit)); printf("Startzeit: %s", ctime(&startzeit));
if(dauer) if(dauer)
printf("Dauer: %02u:%02u:%02u (%umin, %us)\n", dauer/3600, (dauer%3600)/60, dauer%60, dauer/60, dauer); printf("Dauer: %02u:%02u:%02u (%umin, %us)\n", dauer/3600, (dauer%3600)/60, dauer%60, dauer/60, dauer);
*/ */
for_each(times.begin(), times.end(), printSItime()); for_each(times.begin(), times.end(), printSItime());
for_each(ratings.begin(), ratings.end(), printSIparentalRating()); for_each(ratings.begin(), ratings.end(), printSIparentalRating());
for_each(linkage_descs.begin(), linkage_descs.end(), printSIlinkage()); for_each(linkage_descs.begin(), linkage_descs.end(), printSIlinkage());

4
src/sectionsd/SIlanguage.cpp
View File

@@ -142,7 +142,7 @@ bool SIlanguage::loadLanguages()
pthread_mutex_unlock(&languages_lock); pthread_mutex_unlock(&languages_lock);
return true; return true;
error: error:
tmpLang.push_back("OFF"); tmpLang.push_back("OFF");
languages = tmpLang; languages = tmpLang;
mode = tmpMode; mode = tmpMode;
@@ -188,7 +188,7 @@ bool SIlanguage::saveLanguages()
pthread_mutex_unlock(&languages_lock); pthread_mutex_unlock(&languages_lock);
return true; return true;
error: error:
pthread_mutex_unlock(&languages_lock); pthread_mutex_unlock(&languages_lock);
return false; return false;
} }

16
src/sectionsd/SIsections.cpp
View File

@@ -130,7 +130,10 @@ inline unsigned min(unsigned a, unsigned b)
static int get_table(unsigned char hi, unsigned char mid, unsigned char lo) static int get_table(unsigned char hi, unsigned char mid, unsigned char lo)
{ {
char lang[4]; char lang[4];
lang[0] = hi; lang[1] = mid; lang[2] = lo; lang[3] = 0; lang[0] = hi;
lang[1] = mid;
lang[2] = lo;
lang[3] = 0;
if(!strcmp(lang, "pol")) if(!strcmp(lang, "pol"))
return 2; return 2;
else if(!strcmp(lang, "tur")) else if(!strcmp(lang, "tur"))
@@ -420,7 +423,7 @@ void SIsectionEIT::parseShortEventDescriptor(const char *buf, SIevent &e, unsign
#endif #endif
} else } else
#endif // 0 #endif // 0
{ {
#ifdef ENABLE_FREESATEPG #ifdef ENABLE_FREESATEPG
// e.setName(language, buf[0] == 0x1f ? freesatHuffmanDecode(std::string(buf, evt->event_name_length)) : std::string(buf, evt->event_name_length)); // e.setName(language, buf[0] == 0x1f ? freesatHuffmanDecode(std::string(buf, evt->event_name_length)) : std::string(buf, evt->event_name_length));
@@ -444,7 +447,7 @@ void SIsectionEIT::parseShortEventDescriptor(const char *buf, SIevent &e, unsign
#endif #endif
} else } else
#endif // 0 #endif // 0
{ {
#ifdef ENABLE_FREESATEPG #ifdef ENABLE_FREESATEPG
// e.setText(language, buf[1] == 0x1f ? freesatHuffmanDecode(std::string(++buf, textlength)) : std::string(++buf, textlength)); // e.setText(language, buf[1] == 0x1f ? freesatHuffmanDecode(std::string(++buf, textlength)) : std::string(++buf, textlength));
std::string tmp_str = buf[1] == 0x1f ? freesatHuffmanDecode(std::string(++buf, textlength)) : std::string(++buf, textlength); std::string tmp_str = buf[1] == 0x1f ? freesatHuffmanDecode(std::string(++buf, textlength)) : std::string(++buf, textlength);
@@ -707,7 +710,7 @@ void SIsectionPPT::parsePrivateContentTransmissionDescriptor(const char *buf, SI
tm_buf[0] = *(p); tm_buf[0] = *(p);
tm_buf[1] = *(p+1); tm_buf[1] = *(p+1);
starttime_loop_length = (*(p+2))/3; starttime_loop_length = (*(p+2))/3;
for (i=0;i<starttime_loop_length; i++) { for (i=0; i<starttime_loop_length; i++) {
tm_buf[2] = *(p+3*i+3); tm_buf[2] = *(p+3*i+3);
tm_buf[3] = *(p+3*i+4); tm_buf[3] = *(p+3*i+4);
tm_buf[4] = *(p+3*i+5); tm_buf[4] = *(p+3*i+5);
@@ -788,7 +791,8 @@ void SIsectionPPT::parse(void)
actPos = &buffer[sizeof(SI_section_PPT_header)]; actPos = &buffer[sizeof(SI_section_PPT_header)];
/*while (actPos < &buffer[bufferLength])*/ { /*while (actPos < &buffer[bufferLength])*/
{
SIevent e; SIevent e;
descriptors_loop_length = (((SI_section_PPT_header*)buffer)->descriptor_section_length_hi << 8) | ((SI_section_PPT_header*)buffer)->descriptor_section_length_lo; descriptors_loop_length = (((SI_section_PPT_header*)buffer)->descriptor_section_length_hi << 8) | ((SI_section_PPT_header*)buffer)->descriptor_section_length_lo;
e.eventID = (unsigned short)(content_id()); // ?? e.eventID = (unsigned short)(content_id()); // ??
@@ -1318,7 +1322,7 @@ void SIsectionNIT::parse(void)
// ansonsten die Anzahl gelesener Bytes // ansonsten die Anzahl gelesener Bytes
inline int readNbytes(int fd, char *buf, int n, unsigned timeoutInSeconds) inline int readNbytes(int fd, char *buf, int n, unsigned timeoutInSeconds)
{ {
int j; int j;
for(j=0; j<n;) { for(j=0; j<n;) {
struct pollfd ufds; struct pollfd ufds;
// memset(&ufds, 0, sizeof(ufds)); // memset(&ufds, 0, sizeof(ufds));

10
src/sectionsd/SIutils.cpp
View File

@@ -224,16 +224,16 @@ int saveStringToXMLfile(FILE *out, const char *c, int /*withControlCodes*/)
if(!c) if(!c)
return 1; return 1;
// Die Umlaute sind ISO-8859-9 [5] // Die Umlaute sind ISO-8859-9 [5]
/* /*
char buf[6000]; char buf[6000];
int inlen=strlen(c); int inlen=strlen(c);
int outlen=sizeof(buf); int outlen=sizeof(buf);
// UTF8Toisolat1((unsigned char *)buf, &outlen, (const unsigned char *)c, &inlen); // UTF8Toisolat1((unsigned char *)buf, &outlen, (const unsigned char *)c, &inlen);
isolat1ToUTF8((unsigned char *)buf, &outlen, (const unsigned char *)c, &inlen); isolat1ToUTF8((unsigned char *)buf, &outlen, (const unsigned char *)c, &inlen);
buf[outlen]=0; buf[outlen]=0;
c=buf; c=buf;
*/ */
for(;*c; c++) { for(; *c; c++) {
switch ((unsigned char)*c) { switch ((unsigned char)*c) {
case '<': case '<':
fprintf(out, "&lt;"); fprintf(out, "&lt;");
@@ -290,7 +290,7 @@ void removeControlCodes(char *string)
{ {
if(!string) if(!string)
return; return;
for(;*string; ) for(; *string; )
if (!((*string>=32) && (((unsigned char)*string)<128))) if (!((*string>=32) && (((unsigned char)*string)<128)))
memmove(string, string+1, strlen(string+1)+1); memmove(string, string+1, strlen(string+1)+1);
else else

18
src/sectionsd/dmx.cpp
View File

@@ -157,8 +157,10 @@ void DMX::lock(void)
int rc = pthread_mutex_lock(&start_stop_mutex); int rc = pthread_mutex_lock(&start_stop_mutex);
if (rc != 0) if (rc != 0)
{ {
fprintf(stderr, "[sectionsd] mutex_lock: %d %d %d\n", rc, EINVAL, EDEADLK); fflush(stderr); fprintf(stderr, "[sectionsd] mutex_lock: %d %d %d\n", rc, EINVAL, EDEADLK);
fprintf(stderr, "[sectionsd] pid: %d\n", getpid()); fflush(stderr); fflush(stderr);
fprintf(stderr, "[sectionsd] pid: %d\n", getpid());
fflush(stderr);
} }
#else #else
pthread_mutex_lock(&start_stop_mutex); pthread_mutex_lock(&start_stop_mutex);
@@ -172,8 +174,10 @@ void DMX::unlock(void)
int rc = pthread_mutex_unlock(&start_stop_mutex); int rc = pthread_mutex_unlock(&start_stop_mutex);
if (rc != 0) if (rc != 0)
{ {
fprintf(stderr, "[sectionsd] mutex_unlock: %d %d %d\n", rc, EINVAL, EPERM); fflush(stderr); fprintf(stderr, "[sectionsd] mutex_unlock: %d %d %d\n", rc, EINVAL, EPERM);
fprintf(stderr, "[sectionsd] pid: %d\n", getpid()); fflush(stderr); fflush(stderr);
fprintf(stderr, "[sectionsd] pid: %d\n", getpid());
fflush(stderr);
} }
#else #else
pthread_mutex_unlock(&start_stop_mutex); pthread_mutex_unlock(&start_stop_mutex);
@@ -465,7 +469,7 @@ int DMX::immediate_start(void)
{ {
if (isOpen()) if (isOpen())
{ {
xprintf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>DMX::imediate_start: isOpen()<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n"); xprintf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>DMX::imediate_start: isOpen()<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
closefd(); closefd();
} }
@@ -648,7 +652,7 @@ int DMX::change(const int new_filter_index, const int new_current_service)
first_skipped = 0; first_skipped = 0;
#if 0 #if 0
/* i have to think about this. This #if 0 now makes .change() automatically unpause the /* i have to think about this. This #if 0 now makes .change() automatically unpause the
* demux. No idea if there are negative side effects - we will find out :) -- seife * demux. No idea if there are negative side effects - we will find out :) -- seife
*/ */
if (!isOpen()) if (!isOpen())
@@ -808,7 +812,7 @@ int DMX::dropCachedSectionIDs()
{ {
lock(); lock();
/* i think that those checks are wrong for dropCachedSectionIDs(), since /* i think that those checks are wrong for dropCachedSectionIDs(), since
this is called from the housekeeping thread while sectionsd might be this is called from the housekeeping thread while sectionsd might be
idle waiting for the EIT update filter to trigger -- seife idle waiting for the EIT update filter to trigger -- seife
*/ */

8
src/sectionsd/dmx.h
View File

@@ -41,7 +41,7 @@ typedef unsigned char version_number_t;
class DMX class DMX
{ {
private: private:
int fd; int fd;
cDemux * dmx; cDemux * dmx;
@@ -54,7 +54,9 @@ class DMX
unsigned char eit_version; unsigned char eit_version;
bool cache; /* should read sections be cached? true for all but dmxCN */ bool cache; /* should read sections be cached? true for all but dmxCN */
inline bool isOpen(void) { return (fd != -1); } inline bool isOpen(void) {
return (fd != -1);
}
int immediate_start(void); /* mutex must be locked before and unlocked after this method */ int immediate_start(void); /* mutex must be locked before and unlocked after this method */
int immediate_stop(void); /* mutex must be locked before and unlocked after this method */ int immediate_stop(void); /* mutex must be locked before and unlocked after this method */
@@ -62,7 +64,7 @@ class DMX
sections_id_t create_sections_id(const unsigned char table_id, const unsigned short extension_id, const unsigned char section_number, const unsigned short onid, const unsigned short tsid); sections_id_t create_sections_id(const unsigned char table_id, const unsigned short extension_id, const unsigned char section_number, const unsigned short onid, const unsigned short tsid);
ssize_t readNbytes(int fd, char * buf, const size_t n, unsigned timeoutInMSeconds); ssize_t readNbytes(int fd, char * buf, const size_t n, unsigned timeoutInMSeconds);
public: public:
struct s_filters struct s_filters
{ {
unsigned char filter; unsigned char filter;

2
src/sectionsd/dmxapi.cpp
View File

@@ -89,7 +89,7 @@ struct SI_section_TDT_header
unsigned char reserved_future_use : 1; unsigned char reserved_future_use : 1;
unsigned char reserved1 : 2; unsigned char reserved1 : 2;
unsigned short section_length : 12; unsigned short section_length : 12;
/* uint64_t UTC_time : 40;*/ /* uint64_t UTC_time : 40;*/
UTC_t UTC_time; UTC_t UTC_time;
} }
__attribute__ ((packed)); /* 8 bytes */ __attribute__ ((packed)); /* 8 bytes */

619
src/sectionsd/edvbstring.cpp
View File

@@ -38,119 +38,133 @@ int readEncodingFile()
return -1; return -1;
} }
// 8859-x to ucs-16 coding tables. taken from www.unicode.org/Public/MAPPINGS/ISO8859/ // 8859-x to ucs-16 coding tables. taken from www.unicode.org/Public/MAPPINGS/ISO8859/
static unsigned long c88592[96]={ static unsigned long c88592[96]= {
0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7, 0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B, 0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7, 0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7, 0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C, 0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7, 0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E, 0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7, 0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF, 0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7, 0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F, 0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7, 0x0142, /*0x0159,*/ 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9}; 0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7, 0x0142, /*0x0159,*/ 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
};
static unsigned long c88593[96]={ static unsigned long c88593[96]= {
0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0x0000, 0x0124, 0x00A7, 0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0x0000, 0x017B, 0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0x0000, 0x0124, 0x00A7, 0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0x0000, 0x017B,
0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7, 0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0x0000, 0x017C, 0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7, 0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0x0000, 0x017C,
0x00C0, 0x00C1, 0x00C2, 0x0000, 0x00C4, 0x010A, 0x0108, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00C0, 0x00C1, 0x00C2, 0x0000, 0x00C4, 0x010A, 0x0108, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x0000, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7, 0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF, 0x0000, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7, 0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x0000, 0x00E4, 0x010B, 0x0109, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00E0, 0x00E1, 0x00E2, 0x0000, 0x00E4, 0x010B, 0x0109, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x0000, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7, 0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9}; 0x0000, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7, 0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9
};
static unsigned long c88594[96]={ static unsigned long c88594[96]= {
0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7, 0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF, 0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7, 0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF,
0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7, 0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B, 0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7, 0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B,
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A, 0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A,
0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF, 0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF,
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B, 0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B,
0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9}; 0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9
};
static unsigned long c88595[96]={ static unsigned long c88595[96]= {
0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 0x040E, 0x040F, 0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407, 0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 0x040E, 0x040F,
0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F}; 0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F
};
static unsigned long c88596[96]={ static unsigned long c88596[96]= {
0x00A0, 0x0000, 0x0000, 0x0000, 0x00A4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x060C, 0x00AD, 0x0000, 0x0000, 0x00A0, 0x0000, 0x0000, 0x0000, 0x00A4, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x060C, 0x00AD, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x061B, 0x0000, 0x0000, 0x0000, 0x061F, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x061B, 0x0000, 0x0000, 0x0000, 0x061F,
0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F, 0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627, 0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637, 0x0638, 0x0639, 0x063A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F, 0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647, 0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}; 0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
};
static unsigned long c88597[96]={ static unsigned long c88597[96]= {
0x00A0, 0x2018, 0x2019, 0x00A3, 0x20AC, 0x20AF, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x037A, 0x00AB, 0x00AC, 0x00AD, 0x0000, 0x2015, 0x00A0, 0x2018, 0x2019, 0x00A3, 0x20AC, 0x20AF, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x037A, 0x00AB, 0x00AC, 0x00AD, 0x0000, 0x2015,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x0385, 0x0386, 0x00B7, 0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x0385, 0x0386, 0x00B7, 0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
0x03A0, 0x03A1, 0x0000, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03A0, 0x03A1, 0x0000, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x0000}; 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0x0000
};
static unsigned long c88598[96]={ static unsigned long c88598[96]= {
0x00A0, 0x0000, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00A0, 0x0000, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x0000, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017,
0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF, 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7, 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x0000, 0x0000, 0x200E, 0x200F, 0x0000}; 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7, 0x05E8, 0x05E9, 0x05EA, 0x0000, 0x0000, 0x200E, 0x200F, 0x0000
};
static unsigned long c88599[96]={ static unsigned long c88599[96]= {
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF, 0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF}; 0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF
};
static unsigned long c885910[96]={ static unsigned long c885910[96]= {
0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7, 0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A, 0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7, 0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A,
0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7, 0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B, 0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7, 0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B,
0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF, 0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E, 0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF,
0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168, 0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168, 0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF, 0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F, 0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF,
0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169, 0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138}; 0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169, 0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138
};
static unsigned long c885911[96]={ static unsigned long c885911[96]= {
0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07, 0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F, 0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07, 0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17, 0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F, 0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17, 0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27, 0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F, 0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27, 0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37, 0x0E38, 0x0E39, 0x0E3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0E3F, 0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37, 0x0E38, 0x0E39, 0x0E3A, 0x0000, 0x0000, 0x0000, 0x0000, 0x0E3F,
0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47, 0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F, 0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47, 0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0000, 0x0000, 0x0000, 0x0000}; 0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57, 0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0x0000, 0x0000, 0x0000, 0x0000
};
static unsigned long c885913[96]={ static unsigned long c885913[96]= {
0x00A0, 0x201D, 0x00A2, 0x00A3, 0x00A4, 0x201E, 0x00A6, 0x00A7, 0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6, 0x00A0, 0x201D, 0x00A2, 0x00A3, 0x00A4, 0x201E, 0x00A6, 0x00A7, 0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x201C, 0x00B5, 0x00B6, 0x00B7, 0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x201C, 0x00B5, 0x00B6, 0x00B7, 0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112, 0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B, 0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112, 0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7, 0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF, 0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7, 0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113, 0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C, 0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113, 0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7, 0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x2019}; 0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7, 0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x2019
};
static unsigned long c885914[96]={ static unsigned long c885914[96]= {
0x00A0, 0x1E02, 0x1E03, 0x00A3, 0x010A, 0x010B, 0x1E0A, 0x00A7, 0x1E80, 0x00A9, 0x1E82, 0x1E0B, 0x1EF2, 0x00AD, 0x00AE, 0x0178, 0x00A0, 0x1E02, 0x1E03, 0x00A3, 0x010A, 0x010B, 0x1E0A, 0x00A7, 0x1E80, 0x00A9, 0x1E82, 0x1E0B, 0x1EF2, 0x00AD, 0x00AE, 0x0178,
0x1E1E, 0x1E1F, 0x0120, 0x0121, 0x1E40, 0x1E41, 0x00B6, 0x1E56, 0x1E81, 0x1E57, 0x1E83, 0x1E60, 0x1EF3, 0x1E84, 0x1E85, 0x1E61, 0x1E1E, 0x1E1F, 0x0120, 0x0121, 0x1E40, 0x1E41, 0x00B6, 0x1E56, 0x1E81, 0x1E57, 0x1E83, 0x1E60, 0x1EF3, 0x1E84, 0x1E85, 0x1E61,
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x0174, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x1E6A, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x0176, 0x00DF, 0x0174, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x1E6A, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x0176, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x0175, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x1E6B, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x0177, 0x00FF}; 0x0175, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x1E6B, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x0177, 0x00FF
};
static unsigned long c885915[96]={ static unsigned long c885915[96]= {
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x0160, 0x00A7, 0x0161, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x0160, 0x00A7, 0x0161, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x017D, 0x00B5, 0x00B6, 0x00B7, 0x017E, 0x00B9, 0x00BA, 0x00BB, 0x0152, 0x0153, 0x0178, 0x00BF, 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x017D, 0x00B5, 0x00B6, 0x00B7, 0x017E, 0x00B9, 0x00BA, 0x00BB, 0x0152, 0x0153, 0x0178, 0x00BF,
0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF}; 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
};
static unsigned long c885916[96]={ static unsigned long c885916[96]= {
0x00A0, 0x0104, 0x0105, 0x0141, 0x20AC, 0x201E, 0x0160, 0x00A7, 0x0161, 0x00A9, 0x0218, 0x00AB, 0x0179, 0x00AD, 0x017A, 0x017B, 0x00A0, 0x0104, 0x0105, 0x0141, 0x20AC, 0x201E, 0x0160, 0x00A7, 0x0161, 0x00A9, 0x0218, 0x00AB, 0x0179, 0x00AD, 0x017A, 0x017B,
0x00B0, 0x00B1, 0x010C, 0x0142, 0x017D, 0x201D, 0x00B6, 0x00B7, 0x017E, 0x010D, 0x0219, 0x00BB, 0x0152, 0x0153, 0x0178, 0x017C, 0x00B0, 0x00B1, 0x010C, 0x0142, 0x017D, 0x201D, 0x00B6, 0x00B7, 0x017E, 0x010D, 0x0219, 0x00BB, 0x0152, 0x0153, 0x0178, 0x017C,
0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0106, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0106, 0x00C6, 0x00C7, 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
0x0110, 0x0143, 0x00D2, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x015A, 0x0170, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0118, 0x021A, 0x00DF, 0x0110, 0x0143, 0x00D2, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x015A, 0x0170, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0118, 0x021A, 0x00DF,
0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x0107, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x0107, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
0x0111, 0x0144, 0x00F2, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x015B, 0x0171, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0119, 0x021B, 0x00FF}; 0x0111, 0x0144, 0x00F2, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x015B, 0x0171, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0119, 0x021B, 0x00FF
};
// Two Char Mapping ( many polish services and UPC Direct/HBO services) // Two Char Mapping ( many polish services and UPC Direct/HBO services)
// get from http://mitglied.lycos.de/buran/charsets/videotex-suppl.html // get from http://mitglied.lycos.de/buran/charsets/videotex-suppl.html
@@ -162,135 +176,364 @@ static inline unsigned int doVideoTexSuppl(char c1, char c2)
case 0xC1: // grave case 0xC1: // grave
switch (c2) switch (c2)
{ {
case 0x61: return 224; case 0x41: return 192; case 0x61:
case 0x65: return 232; case 0x45: return 200; return 224;
case 0x69: return 236; case 0x49: return 204; case 0x41:
case 0x6f: return 242; case 0x4f: return 210; return 192;
case 0x75: return 249; case 0x55: return 217; case 0x65:
default: return 0; return 232;
case 0x45:
return 200;
case 0x69:
return 236;
case 0x49:
return 204;
case 0x6f:
return 242;
case 0x4f:
return 210;
case 0x75:
return 249;
case 0x55:
return 217;
default:
return 0;
} }
case 0xC2: // acute case 0xC2: // acute
switch (c2) switch (c2)
{ {
case 0x61: return 225; case 0x41: return 193; case 0x61:
case 0x65: return 233; case 0x45: return 201; return 225;
case 0x69: return 237; case 0x49: return 205; case 0x41:
case 0x6f: return 243; case 0x4f: return 211; return 193;
case 0x75: return 250; case 0x55: return 218; case 0x65:
case 0x79: return 253; case 0x59: return 221; return 233;
case 0x63: return 263; case 0x43: return 262; case 0x45:
case 0x6c: return 314; case 0x4c: return 313; return 201;
case 0x6e: return 324; case 0x4e: return 323; case 0x69:
case 0x72: return 341; case 0x52: return 340; return 237;
case 0x73: return 347; case 0x53: return 346; case 0x49:
case 0x7a: return 378; case 0x5a: return 377; return 205;
default: return 0; case 0x6f:
return 243;
case 0x4f:
return 211;
case 0x75:
return 250;
case 0x55:
return 218;
case 0x79:
return 253;
case 0x59:
return 221;
case 0x63:
return 263;
case 0x43:
return 262;
case 0x6c:
return 314;
case 0x4c:
return 313;
case 0x6e:
return 324;
case 0x4e:
return 323;
case 0x72:
return 341;
case 0x52:
return 340;
case 0x73:
return 347;
case 0x53:
return 346;
case 0x7a:
return 378;
case 0x5a:
return 377;
default:
return 0;
} }
case 0xC3: // cedilla case 0xC3: // cedilla
switch (c2) switch (c2)
{ {
case 0x61: return 226; case 0x41: return 194; case 0x61:
case 0x65: return 234; case 0x45: return 202; return 226;
case 0x69: return 238; case 0x49: return 206; case 0x41:
case 0x6f: return 244; case 0x4f: return 212; return 194;
case 0x75: return 251; case 0x55: return 219; case 0x65:
case 0x79: return 375; case 0x59: return 374; return 234;
case 0x63: return 265; case 0x43: return 264; case 0x45:
case 0x67: return 285; case 0x47: return 284; return 202;
case 0x68: return 293; case 0x48: return 292; case 0x69:
case 0x6a: return 309; case 0x4a: return 308; return 238;
case 0x73: return 349; case 0x53: return 348; case 0x49:
case 0x77: return 373; case 0x57: return 372; return 206;
default: return 0; case 0x6f:
return 244;
case 0x4f:
return 212;
case 0x75:
return 251;
case 0x55:
return 219;
case 0x79:
return 375;
case 0x59:
return 374;
case 0x63:
return 265;
case 0x43:
return 264;
case 0x67:
return 285;
case 0x47:
return 284;
case 0x68:
return 293;
case 0x48:
return 292;
case 0x6a:
return 309;
case 0x4a:
return 308;
case 0x73:
return 349;
case 0x53:
return 348;
case 0x77:
return 373;
case 0x57:
return 372;
default:
return 0;
} }
case 0xC4: // tilde case 0xC4: // tilde
switch (c2) switch (c2)
{ {
case 0x61: return 227; case 0x41: return 195; case 0x61:
case 0x6e: return 241; case 0x4e: return 209; return 227;
case 0x69: return 297; case 0x49: return 296; case 0x41:
case 0x6f: return 245; case 0x4f: return 213; return 195;
case 0x75: return 361; case 0x55: return 360; case 0x6e:
default: return 0; return 241;
case 0x4e:
return 209;
case 0x69:
return 297;
case 0x49:
return 296;
case 0x6f:
return 245;
case 0x4f:
return 213;
case 0x75:
return 361;
case 0x55:
return 360;
default:
return 0;
} }
case 0xC6: // breve case 0xC6: // breve
switch (c2) switch (c2)
{ {
case 0x61: return 259; case 0x41: return 258; case 0x61:
case 0x67: return 287; case 0x47: return 286; return 259;
case 0x75: return 365; case 0x55: return 364; case 0x41:
default: return 0; return 258;
case 0x67:
return 287;
case 0x47:
return 286;
case 0x75:
return 365;
case 0x55:
return 364;
default:
return 0;
} }
case 0xC7: // dot above case 0xC7: // dot above
switch (c2) switch (c2)
{ {
case 0x63: return 267; case 0x43: return 266; case 0x63:
case 0x65: return 279; case 0x45: return 278; return 267;
case 0x67: return 289; case 0x47: return 288; case 0x43:
case 0x49: return 304; case 0x7a: return 380; return 266;
case 0x5a: return 379; case 0x65:
default: return 0; return 279;
case 0x45:
return 278;
case 0x67:
return 289;
case 0x47:
return 288;
case 0x49:
return 304;
case 0x7a:
return 380;
case 0x5a:
return 379;
default:
return 0;
} }
case 0xC8: // diaeresis case 0xC8: // diaeresis
switch (c2) switch (c2)
{ {
case 0x61: return 228; case 0x41: return 196; case 0x61:
case 0x65: return 235; case 0x45: return 203; return 228;
case 0x69: return 239; case 0x49: return 207; case 0x41:
case 0x6f: return 246; case 0x4f: return 214; return 196;
case 0x75: return 252; case 0x55: return 220; case 0x65:
case 0x79: return 255; case 0x59: return 376; return 235;
default: return 0; case 0x45:
return 203;
case 0x69:
return 239;
case 0x49:
return 207;
case 0x6f:
return 246;
case 0x4f:
return 214;
case 0x75:
return 252;
case 0x55:
return 220;
case 0x79:
return 255;
case 0x59:
return 376;
default:
return 0;
} }
case 0xCA: // ring above case 0xCA: // ring above
switch (c2) switch (c2)
{ {
case 0x61: return 229; case 0x41: return 197; case 0x61:
case 0x75: return 367; case 0x55: return 366; return 229;
default: return 0; case 0x41:
return 197;
case 0x75:
return 367;
case 0x55:
return 366;
default:
return 0;
} }
case 0xCB: // cedilla case 0xCB: // cedilla
switch (c2) switch (c2)
{ {
case 0x63: return 231; case 0x43: return 199; case 0x63:
case 0x67: return 291; case 0x47: return 290; return 231;
case 0x6b: return 311; case 0x4b: return 310; case 0x43:
case 0x6c: return 316; case 0x4c: return 315; return 199;
case 0x6e: return 326; case 0x4e: return 325; case 0x67:
case 0x72: return 343; case 0x52: return 342; return 291;
case 0x73: return 351; case 0x53: return 350; case 0x47:
case 0x74: return 355; case 0x54: return 354; return 290;
default: return 0; case 0x6b:
return 311;
case 0x4b:
return 310;
case 0x6c:
return 316;
case 0x4c:
return 315;
case 0x6e:
return 326;
case 0x4e:
return 325;
case 0x72:
return 343;
case 0x52:
return 342;
case 0x73:
return 351;
case 0x53:
return 350;
case 0x74:
return 355;
case 0x54:
return 354;
default:
return 0;
} }
case 0xCD: // double acute accent case 0xCD: // double acute accent
switch (c2) switch (c2)
{ {
case 0x6f: return 337; case 0x4f: return 336; case 0x6f:
case 0x75: return 369; case 0x55: return 368; return 337;
default: return 0; case 0x4f:
return 336;
case 0x75:
return 369;
case 0x55:
return 368;
default:
return 0;
} }
case 0xCE: // ogonek case 0xCE: // ogonek
switch (c2) switch (c2)
{ {
case 0x61: return 261; case 0x41: return 260; case 0x61:
case 0x65: return 281; case 0x45: return 280; return 261;
case 0x69: return 303; case 0x49: return 302; case 0x41:
case 0x75: return 371; case 0x55: return 370; return 260;
default: return 0; case 0x65:
return 281;
case 0x45:
return 280;
case 0x69:
return 303;
case 0x49:
return 302;
case 0x75:
return 371;
case 0x55:
return 370;
default:
return 0;
} }
case 0xCF: // caron case 0xCF: // caron
switch (c2) switch (c2)
{ {
case 0x63: return 269; case 0x43: return 268; case 0x63:
case 0x64: return 271; case 0x44: return 270; return 269;
case 0x65: return 283; case 0x45: return 282; case 0x43:
case 0x6c: return 318; case 0x4c: return 317; return 268;
case 0x6e: return 328; case 0x4e: return 327; case 0x64:
case 0x72: return 345; case 0x52: return 344; return 271;
case 0x73: return 353; case 0x53: return 352; case 0x44:
case 0x74: return 357; case 0x54: return 356; return 270;
case 0x7a: return 382; case 0x5a: return 381; case 0x65:
default: return 0; return 283;
case 0x45:
return 282;
case 0x6c:
return 318;
case 0x4c:
return 317;
case 0x6e:
return 328;
case 0x4e:
return 327;
case 0x72:
return 345;
case 0x52:
return 344;
case 0x73:
return 353;
case 0x53:
return 352;
case 0x74:
return 357;
case 0x54:
return 356;
case 0x7a:
return 382;
case 0x5a:
return 381;
default:
return 0;
} }
} }
return 0; return 0;
@@ -325,7 +568,7 @@ static inline unsigned int recode(unsigned char d, int cp)
return c885910[d-0xA0]; return c885910[d-0xA0];
case 11:// 8859-11 -> unicode mapping case 11:// 8859-11 -> unicode mapping
return c885911[d-0xA0]; return c885911[d-0xA0];
/* case 12:// 8859-12 -> unicode mapping // reserved for indian use.. /* case 12:// 8859-12 -> unicode mapping // reserved for indian use..
return c885912[d-0xA0];*/ return c885912[d-0xA0];*/
case 13:// 8859-13 -> unicode mapping case 13:// 8859-13 -> unicode mapping
return c885913[d-0xA0]; return c885913[d-0xA0];
@@ -468,7 +711,7 @@ eString convertUTF8DVB(const eString &string, int table)
unsigned char buf[len]; unsigned char buf[len];
for(int i=0;i<len;i++) for(int i=0; i<len; i++)
{ {
unsigned char c1=string[i]; unsigned char c1=string[i];
unsigned int c; unsigned int c;
@@ -517,7 +760,7 @@ eString convertUTF8DVB(const eString &string, int table)
case 11: case 11:
coding_table = c885911; coding_table = c885911;
break; break;
/* case 12: // reserved.. for indian use /* case 12: // reserved.. for indian use
coding_table = c885912; coding_table = c885912;
break;*/ break;*/
case 13: case 13:
@@ -537,7 +780,7 @@ eString convertUTF8DVB(const eString &string, int table)
break; break;
} }
} }
for(unsigned int j=0;j<96;j++) for(unsigned int j=0; j<96; j++)
{ {
if(coding_table[j]==c) if(coding_table[j]==c)
{ {

357
src/sectionsd/sectionsd.cpp
View File

@@ -406,7 +406,7 @@ static const SIevent nullEvt; // Null-Event
//typedef Loki::SmartPtr<class SIevent, Loki::RefCounted, Loki::DisallowConversion, Loki::NoCheck> //typedef Loki::SmartPtr<class SIevent, Loki::RefCounted, Loki::DisallowConversion, Loki::NoCheck>
// SIeventPtr; // SIeventPtr;
typedef boost::shared_ptr<class SIevent> typedef boost::shared_ptr<class SIevent>
SIeventPtr; SIeventPtr;
typedef std::map<event_id_t, SIeventPtr, std::less<event_id_t> > MySIeventsOrderUniqueKey; typedef std::map<event_id_t, SIeventPtr, std::less<event_id_t> > MySIeventsOrderUniqueKey;
static MySIeventsOrderUniqueKey mySIeventsOrderUniqueKey; static MySIeventsOrderUniqueKey mySIeventsOrderUniqueKey;
@@ -807,7 +807,7 @@ static void addEvent(const SIevent &evt, const unsigned table_id, const time_t z
if ((c1->componentType != c2->componentType) || if ((c1->componentType != c2->componentType) ||
(c1->componentTag != c2->componentTag) || (c1->componentTag != c2->componentTag) ||
(c1->streamContent != c2->streamContent) || (c1->streamContent != c2->streamContent) ||
(strcmp(c1->component.c_str(),c2->component.c_str()) != 0)){ (strcmp(c1->component.c_str(),c2->component.c_str()) != 0)) {
already_exists = false; already_exists = false;
break; break;
} }
@@ -904,12 +904,12 @@ static void addEvent(const SIevent &evt, const unsigned table_id, const time_t z
(SIlanguage::getMode() == CSectionsdClient::LANGUAGE_MODE_OFF) && (zeit != 0)) (SIlanguage::getMode() == CSectionsdClient::LANGUAGE_MODE_OFF) && (zeit != 0))
e->setExtendedText("OFF",""); e->setExtendedText("OFF","");
/* /*
* this is test code, so indentation is deliberately wrong :-) * this is test code, so indentation is deliberately wrong :-)
* we'll hopefully remove this if clause after testing is done * we'll hopefully remove this if clause after testing is done
*/ */
if (slow_addevent) if (slow_addevent)
{ {
std::vector<event_id_t> to_delete; std::vector<event_id_t> to_delete;
unsigned short eventID = e->eventID; unsigned short eventID = e->eventID;
event_id_t e_key = e->uniqueKey(); event_id_t e_key = e->uniqueKey();
@@ -964,11 +964,11 @@ if (slow_addevent)
deleteEvent(to_delete.back()); deleteEvent(to_delete.back());
to_delete.pop_back(); to_delete.pop_back();
} }
} else { } else {
// Damit in den nicht nach Event-ID sortierten Mengen // Damit in den nicht nach Event-ID sortierten Mengen
// Mehrere Events mit gleicher ID sind, diese vorher loeschen // Mehrere Events mit gleicher ID sind, diese vorher loeschen
unlockEvents(); unlockEvents();
} }
deleteEvent(e->uniqueKey()); deleteEvent(e->uniqueKey());
readLockEvents(); readLockEvents();
if (mySIeventsOrderUniqueKey.size() >= max_events) { if (mySIeventsOrderUniqueKey.size() >= max_events) {
@@ -1297,7 +1297,7 @@ static void removeDupEvents(void)
if ((*e1)->get_channel_id() != (*e2)->get_channel_id()) if ((*e1)->get_channel_id() != (*e2)->get_channel_id())
continue; continue;
/* check for same time */ /* check for same time */
if( (*e1)->table_id != 0xFF && (*e2)->table_id != 0xFF ){ if( (*e1)->table_id != 0xFF && (*e2)->table_id != 0xFF ) {
if (((*e1)->times.begin()->startzeit != (*e2)->times.begin()->startzeit) || if (((*e1)->times.begin()->startzeit != (*e2)->times.begin()->startzeit) ||
((*e1)->times.begin()->dauer != (*e2)->times.begin()->dauer)) ((*e1)->times.begin()->dauer != (*e2)->times.begin()->dauer))
continue; continue;
@@ -1431,7 +1431,7 @@ static void removeWasteEvents()
#endif #endif
// SIservicePtr; // SIservicePtr;
typedef boost::shared_ptr<class SIservice> typedef boost::shared_ptr<class SIservice>
SIservicePtr; SIservicePtr;
typedef std::map<t_channel_id, SIservicePtr, std::less<t_channel_id> > MySIservicesOrderUniqueKey; typedef std::map<t_channel_id, SIservicePtr, std::less<t_channel_id> > MySIservicesOrderUniqueKey;
static MySIservicesOrderUniqueKey mySIservicesOrderUniqueKey; static MySIservicesOrderUniqueKey mySIservicesOrderUniqueKey;
@@ -1772,9 +1772,9 @@ static bool addService(const SIservice &s, const int is_actual)
return is_new; return is_new;
} }
// SIsPtr; // SIsPtr;
typedef boost::shared_ptr<class SIbouquet> typedef boost::shared_ptr<class SIbouquet>
SIbouquetPtr; SIbouquetPtr;
typedef std::map<t_bouquetentry_id, SIbouquetPtr, std::less<t_bouquetentry_id> > MySIbouquetsOrderUniqueKey; typedef std::map<t_bouquetentry_id, SIbouquetPtr, std::less<t_bouquetentry_id> > MySIbouquetsOrderUniqueKey;
static MySIbouquetsOrderUniqueKey mySIbouquetsOrderUniqueKey; static MySIbouquetsOrderUniqueKey mySIbouquetsOrderUniqueKey;
@@ -1830,9 +1830,9 @@ static int addBouquetEntry(const SIbouquet &s/*, int section_nr, int count*/)
* *
*/ */
// SIsPtr; // SIsPtr;
typedef boost::shared_ptr<class SInetwork> typedef boost::shared_ptr<class SInetwork>
SInetworkPtr; SInetworkPtr;
typedef std::map<t_transponder_id, SInetworkPtr, std::less<t_transponder_id> > MySItranspondersOrderUniqueKey; typedef std::map<t_transponder_id, SInetworkPtr, std::less<t_transponder_id> > MySItranspondersOrderUniqueKey;
static MySItranspondersOrderUniqueKey mySItranspondersOrderUniqueKey; static MySItranspondersOrderUniqueKey mySItranspondersOrderUniqueKey;
@@ -2086,7 +2086,7 @@ static const SIevent &findNextSIevent(const event_id_t uniqueKey, SItime &zeit)
} }
} }
} }
/* } else { /* } else {
//find next normal //find next normal
eNext = mySIeventsOrderServiceUniqueKeyFirstStartTimeEventUniqueKey.find(eFirst->second); eNext = mySIeventsOrderServiceUniqueKeyFirstStartTimeEventUniqueKey.find(eFirst->second);
eNext++; eNext++;
@@ -2097,7 +2097,7 @@ static const SIevent &findNextSIevent(const event_id_t uniqueKey, SItime &zeit)
nexttimes = (*eNext)->times.begin(); nexttimes = (*eNext)->times.begin();
} }
} }
*/ */
if (nextnvodtimes != eFirst->second->times.end()) if (nextnvodtimes != eFirst->second->times.end())
++nextnvodtimes; ++nextnvodtimes;
//Compare //Compare
@@ -2421,7 +2421,7 @@ static void commandDumpAllServices(int connfd, char* /*data*/, const unsigned /*
s->second->eitScheduleFlag(), s->second->eitPresentFollowingFlag(), s->second->eitScheduleFlag(), s->second->eitPresentFollowingFlag(),
s->second->runningStatus(), s->second->freeCAmode(), s->second->runningStatus(), s->second->freeCAmode(),
s->second->nvods.size()); s->second->nvods.size());
/** soll es in count ? /** soll es in count ?
+ strlen(s->second->serviceName.c_str()) + 1 + strlen(s->second->serviceName.c_str()) + 1
+ strlen(s->second->providerName.c_str()) + 1 + strlen(s->second->providerName.c_str()) + 1
+ 3; **/ + 3; **/
@@ -2666,7 +2666,7 @@ static void sendAllEvents(int connfd, t_channel_id serviceUniqueKey, bool oldFor
if ( responseHeader.dataLength == 1 ) if ( responseHeader.dataLength == 1 )
responseHeader.dataLength = 0; responseHeader.dataLength = 0;
out: out:
if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS) == true) if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS) == true)
{ {
if (responseHeader.dataLength) if (responseHeader.dataLength)
@@ -2963,7 +2963,7 @@ static void commandComponentTagsUniqueKey(int connfd, char *data, const unsigned
responseHeader.dataLength = nResultDataSize; responseHeader.dataLength = nResultDataSize;
out: out:
if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS) == true) if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS) == true)
{ {
if (responseHeader.dataLength) if (responseHeader.dataLength)
@@ -3059,7 +3059,7 @@ static void commandLinkageDescriptorsUniqueKey(int connfd, char *data, const uns
responseHeader.dataLength = nResultDataSize; responseHeader.dataLength = nResultDataSize;
out: out:
if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS) == true) if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS) == true)
{ {
if (responseHeader.dataLength) if (responseHeader.dataLength)
@@ -3215,7 +3215,7 @@ static void commandserviceChanged(int connfd, char *data, const unsigned dataLen
else else
dprintf("[sectionsd] commandserviceChanged: no change...\n"); dprintf("[sectionsd] commandserviceChanged: no change...\n");
out: out:
struct sectionsd::msgResponseHeader msgResponse; struct sectionsd::msgResponseHeader msgResponse;
msgResponse.dataLength = 0; msgResponse.dataLength = 0;
writeNbytes(connfd, (const char *)&msgResponse, sizeof(msgResponse), WRITE_TIMEOUT_IN_SECONDS); writeNbytes(connfd, (const char *)&msgResponse, sizeof(msgResponse), WRITE_TIMEOUT_IN_SECONDS);
@@ -3473,7 +3473,7 @@ static void commandCurrentNextInfoChannelID(int connfd, char *data, const unsign
// response // response
out: out:
pmResponse.dataLength = nResultDataSize; pmResponse.dataLength = nResultDataSize;
bool rc = writeNbytes(connfd, (const char *)&pmResponse, sizeof(pmResponse), WRITE_TIMEOUT_IN_SECONDS); bool rc = writeNbytes(connfd, (const char *)&pmResponse, sizeof(pmResponse), WRITE_TIMEOUT_IN_SECONDS);
@@ -3586,7 +3586,7 @@ static void sendEPG(int connfd, const SIevent& e, const SItime& t, int shortepg
unlockEvents(); unlockEvents();
out: out:
if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) { if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) {
if (responseHeader.dataLength) if (responseHeader.dataLength)
writeNbytes(connfd, msgData, responseHeader.dataLength, WRITE_TIMEOUT_IN_SECONDS); writeNbytes(connfd, msgData, responseHeader.dataLength, WRITE_TIMEOUT_IN_SECONDS);
@@ -3740,7 +3740,7 @@ static void commandGetEPGPrevNext(int connfd, char *data, const unsigned dataLen
); );
unlockEvents(); unlockEvents();
out: out:
if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) { if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) {
if (responseHeader.dataLength) if (responseHeader.dataLength)
writeNbytes(connfd, msgData, responseHeader.dataLength, WRITE_TIMEOUT_IN_SECONDS); writeNbytes(connfd, msgData, responseHeader.dataLength, WRITE_TIMEOUT_IN_SECONDS);
@@ -4017,7 +4017,7 @@ static void sendEventList(int connfd, const unsigned char serviceTyp1, const uns
if ( msgResponse.dataLength == 1 ) if ( msgResponse.dataLength == 1 )
msgResponse.dataLength = 0; msgResponse.dataLength = 0;
out: out:
if (writeNbytes(connfd, (const char *)&msgResponse, sizeof(msgResponse), WRITE_TIMEOUT_IN_SECONDS) == true) if (writeNbytes(connfd, (const char *)&msgResponse, sizeof(msgResponse), WRITE_TIMEOUT_IN_SECONDS) == true)
{ {
if (msgResponse.dataLength) if (msgResponse.dataLength)
@@ -4061,7 +4061,7 @@ static void sendShort(int connfd, const SIevent& e, const SItime& t)
); );
unlockEvents(); unlockEvents();
out: out:
if(writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) { if(writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) {
if (responseHeader.dataLength) if (responseHeader.dataLength)
writeNbytes(connfd, msgData, responseHeader.dataLength, WRITE_TIMEOUT_IN_SECONDS); writeNbytes(connfd, msgData, responseHeader.dataLength, WRITE_TIMEOUT_IN_SECONDS);
@@ -4140,7 +4140,7 @@ static void commandEventListRadioIDs(int connfd, char* data, const unsigned data
dputs("Request of radio event list (IDs).\n"); dputs("Request of radio event list (IDs).\n");
if (dataLength>0) { if (dataLength>0) {
t_channel_id *tmp = (t_channel_id*)data; t_channel_id *tmp = (t_channel_id*)data;
for (uint i=0; i<dataLength/sizeof(t_channel_id); i++){ for (uint i=0; i<dataLength/sizeof(t_channel_id); i++) {
chidlist.push_back(tmp[i]); chidlist.push_back(tmp[i]);
} }
} }
@@ -4309,7 +4309,7 @@ static void commandTimesNVODservice(int connfd, char *data, const unsigned dataL
dprintf("data bytes: %u\n", responseHeader.dataLength); dprintf("data bytes: %u\n", responseHeader.dataLength);
out: out:
if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS)) if (writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS))
{ {
if (responseHeader.dataLength) if (responseHeader.dataLength)
@@ -4382,7 +4382,7 @@ static void commandSetPrivatePid(int connfd, char *data, const unsigned dataLeng
} }
} }
out: out:
struct sectionsd::msgResponseHeader responseHeader; struct sectionsd::msgResponseHeader responseHeader;
responseHeader.dataLength = 0; responseHeader.dataLength = 0;
writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS); writeNbytes(connfd, (const char *)&responseHeader, sizeof(responseHeader), WRITE_TIMEOUT_IN_SECONDS);
@@ -4400,7 +4400,7 @@ static void commandSetSectionsdScanMode(int connfd, char *data, const unsigned d
auto_scanning = *((int*)data); auto_scanning = *((int*)data);
unlockMessaging(); unlockMessaging();
out: out:
struct sectionsd::msgResponseHeader responseHeader; struct sectionsd::msgResponseHeader responseHeader;
responseHeader.dataLength = 0; responseHeader.dataLength = 0;
@@ -4659,7 +4659,7 @@ static void *insertEventsfromFile(void *)
} }
node = node->xmlNextNode; node = node->xmlNextNode;
} }
*/ */
while (xmlGetNextOccurence(node, "time") != NULL) { while (xmlGetNextOccurence(node, "time") != NULL) {
e.times.insert(SItime(xmlGetNumericAttribute(node, "start_time", 10), e.times.insert(SItime(xmlGetNumericAttribute(node, "start_time", 10),
xmlGetNumericAttribute(node, "duration", 10))); xmlGetNumericAttribute(node, "duration", 10)));
@@ -5127,64 +5127,64 @@ struct s_cmd_table
static s_cmd_table connectionCommands[sectionsd::numberOfCommands] = { static s_cmd_table connectionCommands[sectionsd::numberOfCommands] = {
//commandActualEPGchannelName, //commandActualEPGchannelName,
{ commandDummy2, "commandDummy1" }, { commandDummy2, "commandDummy1" },
{ commandEventListTV, "commandEventListTV" }, { commandEventListTV, "commandEventListTV" },
//commandCurrentNextInfoChannelName, //commandCurrentNextInfoChannelName,
{ commandDummy2, "commandDummy2" }, { commandDummy2, "commandDummy2" },
{ commandDumpStatusInformation, "commandDumpStatusInformation" }, { commandDumpStatusInformation, "commandDumpStatusInformation" },
//commandAllEventsChannelName, //commandAllEventsChannelName,
{ commandAllEventsChannelIDSearch, "commandAllEventsChannelIDSearch" }, { commandAllEventsChannelIDSearch, "commandAllEventsChannelIDSearch" },
{ commandDummy2, "commandSetHoursToCache" }, { commandDummy2, "commandSetHoursToCache" },
{ commandDummy2, "commandSetHoursExtendedCache" }, { commandDummy2, "commandSetHoursExtendedCache" },
{ commandDummy2, "commandSetEventsAreOldInMinutes" }, { commandDummy2, "commandSetEventsAreOldInMinutes" },
{ commandDumpAllServices, "commandDumpAllServices" }, { commandDumpAllServices, "commandDumpAllServices" },
{ commandEventListRadio, "commandEventListRadio" }, { commandEventListRadio, "commandEventListRadio" },
{ commandGetNextEPG, "commandGetNextEPG" }, { commandGetNextEPG, "commandGetNextEPG" },
{ commandGetNextShort, "commandGetNextShort" }, { commandGetNextShort, "commandGetNextShort" },
{ commandPauseScanning, "commandPauseScanning" }, { commandPauseScanning, "commandPauseScanning" },
{ commandGetIsScanningActive, "commandGetIsScanningActive" }, { commandGetIsScanningActive, "commandGetIsScanningActive" },
{ commandActualEPGchannelID, "commandActualEPGchannelID" }, { commandActualEPGchannelID, "commandActualEPGchannelID" },
{ commandEventListTVids, "commandEventListTVids" }, { commandEventListTVids, "commandEventListTVids" },
{ commandEventListRadioIDs, "commandEventListRadioIDs" }, { commandEventListRadioIDs, "commandEventListRadioIDs" },
{ commandCurrentNextInfoChannelID, "commandCurrentNextInfoChannelID" }, { commandCurrentNextInfoChannelID, "commandCurrentNextInfoChannelID" },
{ commandEPGepgID, "commandEPGepgID" }, { commandEPGepgID, "commandEPGepgID" },
{ commandEPGepgIDshort, "commandEPGepgIDshort" }, { commandEPGepgIDshort, "commandEPGepgIDshort" },
{ commandComponentTagsUniqueKey, "commandComponentTagsUniqueKey" }, { commandComponentTagsUniqueKey, "commandComponentTagsUniqueKey" },
{ commandAllEventsChannelID, "commandAllEventsChannelID" }, { commandAllEventsChannelID, "commandAllEventsChannelID" },
{ commandTimesNVODservice, "commandTimesNVODservice" }, { commandTimesNVODservice, "commandTimesNVODservice" },
{ commandGetEPGPrevNext, "commandGetEPGPrevNext" }, { commandGetEPGPrevNext, "commandGetEPGPrevNext" },
{ commandGetIsTimeSet, "commandGetIsTimeSet" }, { commandGetIsTimeSet, "commandGetIsTimeSet" },
{ commandserviceChanged, "commandserviceChanged" }, { commandserviceChanged, "commandserviceChanged" },
{ commandLinkageDescriptorsUniqueKey, "commandLinkageDescriptorsUniqueKey" }, { commandLinkageDescriptorsUniqueKey, "commandLinkageDescriptorsUniqueKey" },
{ commandDummy2, "commandPauseSorting" }, { commandDummy2, "commandPauseSorting" },
{ commandRegisterEventClient, "commandRegisterEventClient" }, { commandRegisterEventClient, "commandRegisterEventClient" },
{ commandUnRegisterEventClient, "commandUnRegisterEventClient" }, { commandUnRegisterEventClient, "commandUnRegisterEventClient" },
#ifdef ENABLE_PPT #ifdef ENABLE_PPT
{ commandSetPrivatePid, "commandSetPrivatePid" }, { commandSetPrivatePid, "commandSetPrivatePid" },
#else #else
{ commandDummy2, "commandSetPrivatePid" }, { commandDummy2, "commandSetPrivatePid" },
#endif #endif
#ifdef UPDATE_NETWORKS #ifdef UPDATE_NETWORKS
{ commandSetSectionsdScanMode, "commandSetSectionsdScanMode" }, { commandSetSectionsdScanMode, "commandSetSectionsdScanMode" },
#else #else
{ commandDummy2, "commandSetSectionsdScanMode" }, { commandDummy2, "commandSetSectionsdScanMode" },
#endif #endif
{ commandFreeMemory, "commandFreeMemory" }, { commandFreeMemory, "commandFreeMemory" },
{ commandReadSIfromXML, "commandReadSIfromXML" }, { commandReadSIfromXML, "commandReadSIfromXML" },
{ commandWriteSI2XML, "commandWriteSI2XML" }, { commandWriteSI2XML, "commandWriteSI2XML" },
{ commandLoadLanguages, "commandLoadLanguages" }, { commandLoadLanguages, "commandLoadLanguages" },
{ commandSaveLanguages, "commandSaveLanguages" }, { commandSaveLanguages, "commandSaveLanguages" },
{ commandSetLanguages, "commandSetLanguages" }, { commandSetLanguages, "commandSetLanguages" },
{ commandGetLanguages, "commandGetLanguages" }, { commandGetLanguages, "commandGetLanguages" },
{ commandSetLanguageMode, "commandSetLanguageMode" }, { commandSetLanguageMode, "commandSetLanguageMode" },
{ commandGetLanguageMode, "commandGetLanguageMode" }, { commandGetLanguageMode, "commandGetLanguageMode" },
{ commandSetConfig, "commandSetConfig" }, { commandSetConfig, "commandSetConfig" },
#if 0 #if 0
{ commandRestart, "commandRestart" }, { commandRestart, "commandRestart" },
#else #else
{ commandDummy1, "commandRestart" }, { commandDummy1, "commandRestart" },
#endif #endif
{ commandDummy1, "commandPing" } { commandDummy1, "commandPing" }
}; };
//static void *connectionThread(void *conn) //static void *connectionThread(void *conn)
@@ -6651,7 +6651,8 @@ static void *sdtThread(void *)
pthread_mutex_lock( &dmxSDT.start_stop_mutex ); pthread_mutex_lock( &dmxSDT.start_stop_mutex );
/* this is the "last" thread. Means: if this one goes to sleep, sectionsd /* this is the "last" thread. Means: if this one goes to sleep, sectionsd
sleeps mostly. Worth printing. */ sleeps mostly. Worth printing. */
printdate_ms(stdout);printf("dmxSDT: going to sleep...\n"); printdate_ms(stdout);
printf("dmxSDT: going to sleep...\n");
if ((auto_scanning > 0) && (!startup)) { if ((auto_scanning > 0) && (!startup)) {
if ((auto_scanning == 1) || (auto_scanning == 3)) { if ((auto_scanning == 1) || (auto_scanning == 3)) {
if (updateTP(scanType)) { if (updateTP(scanType)) {
@@ -6921,7 +6922,7 @@ static void *timeThread(void *)
break; break;
sleep(1); sleep(1);
} }
if (bTimeCorrect == true){ // sectionsd started with parameter "-tc" if (bTimeCorrect == true) { // sectionsd started with parameter "-tc"
if (first_time == true) { // only do this once! if (first_time == true) { // only do this once!
time_t actTime; time_t actTime;
actTime=time(NULL); actTime=time(NULL);
@@ -6986,7 +6987,7 @@ static void *timeThread(void *)
else else
seconds = ntprefresh * 60; seconds = ntprefresh * 60;
if(time_ntp){ if(time_ntp) {
xprintf("[%sThread] Time set via NTP, going to sleep for %d seconds.\n", "time", seconds); xprintf("[%sThread] Time set via NTP, going to sleep for %d seconds.\n", "time", seconds);
} }
else { else {
@@ -6996,11 +6997,11 @@ static void *timeThread(void *)
first_time = false; first_time = false;
} }
else { else {
if (!first_time){ if (!first_time) {
/* time was already set, no need to do it again soon when DVB time-blocked channel is tuned */ /* time was already set, no need to do it again soon when DVB time-blocked channel is tuned */
seconds = ntprefresh * 60; seconds = ntprefresh * 60;
} }
else if (!scanning){ else if (!scanning) {
seconds = 60; seconds = 60;
} }
else { else {
@@ -7090,7 +7091,7 @@ int eit_set_update_filter(int *fd)
int eit_stop_update_filter(int *fd) int eit_stop_update_filter(int *fd)
{ {
printf("[sectionsd] stop eit update filter\n"); printf("[sectionsd] stop eit update filter\n");
if(eitDmx) if(eitDmx)
eitDmx->Stop(); eitDmx->Stop();
@@ -7195,8 +7196,7 @@ static void *fseitThread(void *)
dprintf("New Filterindex: %d (ges. %d)\n", dmxFSEIT.filter_index + 1, (signed) dmxFSEIT.filters.size() ); dprintf("New Filterindex: %d (ges. %d)\n", dmxFSEIT.filter_index + 1, (signed) dmxFSEIT.filters.size() );
dmxFSEIT.change( dmxFSEIT.filter_index + 1 ); dmxFSEIT.change( dmxFSEIT.filter_index + 1 );
} }
else else if (dmxFSEIT.filter_index >= 1)
if (dmxFSEIT.filter_index >= 1)
{ {
if (dmxFSEIT.filter_index + 1 < (signed) dmxFSEIT.filters.size() ) if (dmxFSEIT.filter_index + 1 < (signed) dmxFSEIT.filters.size() )
{ {
@@ -7481,7 +7481,7 @@ static void *eitThread(void *)
{ {
#if 0 #if 0
writeLockMessaging(); writeLockMessaging();
if (update_eit){ if (update_eit) {
if (dmxEIT.filters[dmxEIT.filter_index].filter == 0x4e) { if (dmxEIT.filters[dmxEIT.filter_index].filter == 0x4e) {
dprintf("[eitThread] got all current_next - sending event!\n"); dprintf("[eitThread] got all current_next - sending event!\n");
messaging_wants_current_next_Event = false; messaging_wants_current_next_Event = false;
@@ -7540,8 +7540,7 @@ static void *eitThread(void *)
dprintf("New Filterindex: %d (ges. %d)\n", dmxEIT.filter_index + 1, (signed) dmxEIT.filters.size() ); dprintf("New Filterindex: %d (ges. %d)\n", dmxEIT.filter_index + 1, (signed) dmxEIT.filters.size() );
dmxEIT.change( dmxEIT.filter_index + 1 ); dmxEIT.change( dmxEIT.filter_index + 1 );
} }
else else if (dmxEIT.filter_index >= 1)
if (dmxEIT.filter_index >= 1)
{ {
if (dmxEIT.filter_index + 1 < (signed) dmxEIT.filters.size() ) if (dmxEIT.filter_index + 1 < (signed) dmxEIT.filters.size() )
{ {
@@ -8005,7 +8004,8 @@ static void *cnThread(void *)
if (si != mySIservicesNVODorderUniqueKey.end()) if (si != mySIservicesNVODorderUniqueKey.end())
{ {
/* if this never happens in reality, we can remove the whole "else" clause here */ /* if this never happens in reality, we can remove the whole "else" clause here */
printdate_ms(stderr); fprintf(stderr, "NVOD-EVENT in CN-THREAD!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); printdate_ms(stderr);
fprintf(stderr, "NVOD-EVENT in CN-THREAD!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
// Ist ein nvod-event // Ist ein nvod-event
writeLockEvents(); writeLockEvents();
for (SInvodReferences::iterator i = si->second->nvods.begin(); i != si->second->nvods.end(); i++) for (SInvodReferences::iterator i = si->second->nvods.begin(); i != si->second->nvods.end(); i++)
@@ -8024,7 +8024,7 @@ static void *cnThread(void *)
printf("[sectionsd] cnThread ended\n"); printf("[sectionsd] cnThread ended\n");
pthread_exit(NULL); pthread_exit(NULL);
} }
#ifdef ENABLE_PPT #ifdef ENABLE_PPT
@@ -8033,8 +8033,8 @@ static void *cnThread(void *)
// reads EPG-datas // reads EPG-datas
//--------------------------------------------------------------------- //---------------------------------------------------------------------
static void *pptThread(void *) static void *pptThread(void *)
{ {
struct SI_section_header *header; struct SI_section_header *header;
unsigned timeoutInMSeconds = EIT_READ_TIMEOUT; unsigned timeoutInMSeconds = EIT_READ_TIMEOUT;
bool sendToSleepNow = false; bool sendToSleepNow = false;
@@ -8319,13 +8319,13 @@ static void *pptThread(void *)
dputs("[pptThread] end"); dputs("[pptThread] end");
pthread_exit(NULL); pthread_exit(NULL);
} }
#endif #endif
/* helper function for the housekeeping-thread */ /* helper function for the housekeeping-thread */
static void print_meminfo(void) static void print_meminfo(void)
{ {
if (!sections_debug) if (!sections_debug)
return; return;
@@ -8333,14 +8333,14 @@ static void print_meminfo(void)
dprintf("total size of memory occupied by chunks handed out by malloc: %d\n" dprintf("total size of memory occupied by chunks handed out by malloc: %d\n"
"total bytes memory allocated with `sbrk' by malloc, in bytes: %d (%dkB)\n", "total bytes memory allocated with `sbrk' by malloc, in bytes: %d (%dkB)\n",
meminfo.uordblks, meminfo.arena, meminfo.arena / 1024); meminfo.uordblks, meminfo.arena, meminfo.arena / 1024);
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// housekeeping-thread // housekeeping-thread
// does cleaning on fetched datas // does cleaning on fetched datas
//--------------------------------------------------------------------- //---------------------------------------------------------------------
static void *houseKeepingThread(void *) static void *houseKeepingThread(void *)
{ {
int count = 0; int count = 0;
#ifdef UPDATE_NETWORKS #ifdef UPDATE_NETWORKS
char servicename[MAX_SIZE_SERVICENAME]; char servicename[MAX_SIZE_SERVICENAME];
@@ -8379,7 +8379,7 @@ static void *houseKeepingThread(void *)
removeOldEvents(oldEventsAre); // alte Events removeOldEvents(oldEventsAre); // alte Events
dprintf("after removeoldevents\n"); dprintf("after removeoldevents\n");
readLockEvents(); readLockEvents();
printf("[sectionsd] Removed %d old events.\n", anzEventsAlt - mySIeventsOrderUniqueKey.size()); printf("[sectionsd] Removed %d old events.\n", anzEventsAlt - mySIeventsOrderUniqueKey.size());
if (mySIeventsOrderUniqueKey.size() != anzEventsAlt) if (mySIeventsOrderUniqueKey.size() != anzEventsAlt)
{ {
print_meminfo(); print_meminfo();
@@ -8391,7 +8391,7 @@ printf("[sectionsd] Removed %d old events.\n", anzEventsAlt - mySIeventsOrderUni
// lockEvents(); // lockEvents();
removeDupEvents(); removeDupEvents();
readLockEvents(); readLockEvents();
printf("[sectionsd] Removed %d dup events.\n", anzEventsAlt - mySIeventsOrderUniqueKey.size()); printf("[sectionsd] Removed %d dup events.\n", anzEventsAlt - mySIeventsOrderUniqueKey.size());
anzEventsAlt = mySIeventsOrderUniqueKey.size(); anzEventsAlt = mySIeventsOrderUniqueKey.size();
unlockEvents(); unlockEvents();
dprintf("before removewasteepg\n"); dprintf("before removewasteepg\n");
@@ -8518,10 +8518,10 @@ printf("[sectionsd] Removed %d dup events.\n", anzEventsAlt - mySIeventsOrderUni
dprintf("housekeeping-thread ended.\n"); dprintf("housekeeping-thread ended.\n");
pthread_exit(NULL); pthread_exit(NULL);
} }
static void readEPGFilter(void) static void readEPGFilter(void)
{ {
xmlDocPtr filter_parser = parseXmlFile(epg_filter_dir.c_str()); xmlDocPtr filter_parser = parseXmlFile(epg_filter_dir.c_str());
t_original_network_id onid = 0; t_original_network_id onid = 0;
@@ -8553,10 +8553,10 @@ static void readEPGFilter(void)
} }
} }
xmlFreeDoc(filter_parser); xmlFreeDoc(filter_parser);
} }
static void readDVBTimeFilter(void) static void readDVBTimeFilter(void)
{ {
xmlDocPtr filter_parser = parseXmlFile(dvbtime_filter_dir.c_str()); xmlDocPtr filter_parser = parseXmlFile(dvbtime_filter_dir.c_str());
t_original_network_id onid = 0; t_original_network_id onid = 0;
@@ -8585,11 +8585,11 @@ static void readDVBTimeFilter(void)
{ {
dvb_time_update = true; dvb_time_update = true;
} }
} }
#if 0 #if 0
static void readBouquetFilter(void) static void readBouquetFilter(void)
{ {
xmlDocPtr filter_parser = parseXmlFile("/var/tuxbox/config/mybouquets.xml"); xmlDocPtr filter_parser = parseXmlFile("/var/tuxbox/config/mybouquets.xml");
t_bouquet_id bid = 0; t_bouquet_id bid = 0;
@@ -8680,16 +8680,16 @@ static void readBouquetFilter(void)
} }
} }
xmlFreeDoc(filter_parser); xmlFreeDoc(filter_parser);
} }
static void printHelp(void) static void printHelp(void)
{ {
printf("\nUsage: sectionsd [-d][-nu]\n\n"); printf("\nUsage: sectionsd [-d][-nu]\n\n");
} }
// Just to get our listen socket closed cleanly // Just to get our listen socket closed cleanly
static void signalHandler(int signum) static void signalHandler(int signum)
{ {
switch (signum) switch (signum)
{ {
@@ -8699,7 +8699,7 @@ static void signalHandler(int signum)
default: default:
exit(0); exit(0);
} }
} }
#define GETENVI(var) \ #define GETENVI(var) \
env = getenv("SD_"#var); \ env = getenv("SD_"#var); \
@@ -8727,10 +8727,10 @@ static void signalHandler(int signum)
} else fprintf(stderr, "GETENVS("#var") failed\n"); } else fprintf(stderr, "GETENVS("#var") failed\n");
#endif #endif
//int main(int argc, char **argv) //int main(int argc, char **argv)
extern cDemux * dmxUTC; extern cDemux * dmxUTC;
void sectionsd_main_thread(void */*data*/) void sectionsd_main_thread(void */*data*/)
{ {
pthread_t threadTOT, threadEIT, threadCN, threadHouseKeeping; pthread_t threadTOT, threadEIT, threadCN, threadHouseKeeping;
#ifdef UPDATE_NETWORKS #ifdef UPDATE_NETWORKS
pthread_t threadSDT, threadNIT; pthread_t threadSDT, threadNIT;
@@ -8885,7 +8885,8 @@ void sectionsd_main_thread(void */*data*/)
if (ret > 0) { if (ret > 0) {
//printf("[sectionsd] EIT update: len %d, %02X %02X %02X %02X %02X %02X version %02X\n", ret, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], ((SI_section_header*)buf)->version_number); //printf("[sectionsd] EIT update: len %d, %02X %02X %02X %02X %02X %02X version %02X\n", ret, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], ((SI_section_header*)buf)->version_number);
printdate_ms(stdout);printf("EIT Update Filter: new version 0x%x, Activate cnThread\n", ((SI_section_header*)buf)->version_number); printdate_ms(stdout);
printf("EIT Update Filter: new version 0x%x, Activate cnThread\n", ((SI_section_header*)buf)->version_number);
writeLockMessaging(); writeLockMessaging();
// messaging_skipped_sections_ID[0].clear(); // messaging_skipped_sections_ID[0].clear();
// messaging_sections_max_ID[0] = -1; // messaging_sections_max_ID[0] = -1;
@@ -8911,7 +8912,7 @@ void sectionsd_main_thread(void */*data*/)
printf("[sectionsd] stopping...\n"); printf("[sectionsd] stopping...\n");
scanning = 0; scanning = 0;
timeset = true; timeset = true;
printf("broadcasting...\n"); printf("broadcasting...\n");
pthread_mutex_lock(&timeIsSetMutex); pthread_mutex_lock(&timeIsSetMutex);
pthread_cond_broadcast(&timeIsSetCond); pthread_cond_broadcast(&timeIsSetCond);
pthread_mutex_unlock(&timeIsSetMutex); pthread_mutex_unlock(&timeIsSetMutex);
@@ -8934,7 +8935,7 @@ printf("broadcasting...\n");
pthread_cond_broadcast(&dmxSDT.change_cond); pthread_cond_broadcast(&dmxSDT.change_cond);
pthread_mutex_unlock(&dmxSDT.start_stop_mutex); pthread_mutex_unlock(&dmxSDT.start_stop_mutex);
#endif #endif
printf("pausing...\n"); printf("pausing...\n");
dmxEIT.request_pause(); dmxEIT.request_pause();
dmxCN.request_pause(); dmxCN.request_pause();
#ifdef ENABLE_PPT #ifdef ENABLE_PPT
@@ -8953,19 +8954,19 @@ printf("pausing...\n");
pthread_cancel(threadTOT); pthread_cancel(threadTOT);
printf("join 1\n"); printf("join 1\n");
pthread_join(threadTOT, NULL); pthread_join(threadTOT, NULL);
if(dmxUTC) delete dmxUTC; if(dmxUTC) delete dmxUTC;
printf("join 2\n"); printf("join 2\n");
pthread_join(threadEIT, NULL); pthread_join(threadEIT, NULL);
printf("join 3\n"); printf("join 3\n");
pthread_join(threadCN, NULL); pthread_join(threadCN, NULL);
#ifdef ENABLE_PPT #ifdef ENABLE_PPT
printf("join 3\n"); printf("join 3\n");
pthread_join(threadPPT, NULL); pthread_join(threadPPT, NULL);
#endif #endif
#ifdef UPDATE_NETWORKS #ifdef UPDATE_NETWORKS
printf("join 4\n"); printf("join 4\n");
pthread_join(threadSDT, NULL); pthread_join(threadSDT, NULL);
#endif #endif
@@ -8973,9 +8974,9 @@ printf("join 4\n");
if(eitDmx) if(eitDmx)
delete eitDmx; delete eitDmx;
printf("close 1\n"); printf("close 1\n");
dmxEIT.close(); dmxEIT.close();
printf("close 3\n"); printf("close 3\n");
dmxCN.close(); dmxCN.close();
#ifdef ENABLE_FREESATEPG #ifdef ENABLE_FREESATEPG
dmxFSEIT.close(); dmxFSEIT.close();
@@ -8991,10 +8992,10 @@ printf("close 3\n");
printf("[sectionsd] ended\n"); printf("[sectionsd] ended\n");
return; return;
} }
/* was: commandAllEventsChannelID sendAllEvents */ /* was: commandAllEventsChannelID sendAllEvents */
void sectionsd_getEventsServiceKey(t_channel_id serviceUniqueKey, CChannelEventList &eList, char search = 0, std::string search_text = "") void sectionsd_getEventsServiceKey(t_channel_id serviceUniqueKey, CChannelEventList &eList, char search = 0, std::string search_text = "")
{ {
dprintf("sendAllEvents for " PRINTF_CHANNEL_ID_TYPE "\n", serviceUniqueKey); dprintf("sendAllEvents for " PRINTF_CHANNEL_ID_TYPE "\n", serviceUniqueKey);
if ((serviceUniqueKey& 0xFFFFFFFFFFFFULL) != 0) { //0xFFFFFFFFFFFFULL for CREATE_CHANNEL_ID64 if ((serviceUniqueKey& 0xFFFFFFFFFFFFULL) != 0) { //0xFFFFFFFFFFFFULL for CREATE_CHANNEL_ID64
@@ -9052,10 +9053,10 @@ void sectionsd_getEventsServiceKey(t_channel_id serviceUniqueKey, CChannelEventL
unlockEvents(); unlockEvents();
} }
} }
/* was: commandCurrentNextInfoChannelID */ /* was: commandCurrentNextInfoChannelID */
void sectionsd_getCurrentNextServiceKey(t_channel_id uniqueServiceKey, CSectionsdClient::responseGetCurrentNextInfoChannelID& current_next ) void sectionsd_getCurrentNextServiceKey(t_channel_id uniqueServiceKey, CSectionsdClient::responseGetCurrentNextInfoChannelID& current_next )
{ {
dprintf("[sectionsd] Request of current/next information for " PRINTF_CHANNEL_ID_TYPE "\n", uniqueServiceKey); dprintf("[sectionsd] Request of current/next information for " PRINTF_CHANNEL_ID_TYPE "\n", uniqueServiceKey);
SIevent currentEvt; SIevent currentEvt;
@@ -9258,10 +9259,10 @@ void sectionsd_getCurrentNextServiceKey(t_channel_id uniqueServiceKey, CSections
dprintf("change && !messaging_eit_is_busy => dmxCN.change(0)\n"); dprintf("change && !messaging_eit_is_busy => dmxCN.change(0)\n");
dmxCN.change(0); dmxCN.change(0);
} }
} }
/* commandEPGepgIDshort */ /* commandEPGepgIDshort */
bool sectionsd_getEPGidShort(event_id_t epgID, CShortEPGData * epgdata) bool sectionsd_getEPGidShort(event_id_t epgID, CShortEPGData * epgdata)
{ {
bool ret = false; bool ret = false;
dprintf("Request of current EPG for 0x%llx\n", epgID); dprintf("Request of current EPG for 0x%llx\n", epgID);
@@ -9281,10 +9282,10 @@ bool sectionsd_getEPGidShort(event_id_t epgID, CShortEPGData * epgdata)
unlockEvents(); unlockEvents();
return ret; return ret;
} }
#if 0 #if 0
char * parseExtendedEvents(char * dp, CEPGData * epgdata) { char * parseExtendedEvents(char * dp, CEPGData * epgdata) {
char * pItemDescriptions = dp, * pItemDescriptionStart; char * pItemDescriptions = dp, * pItemDescriptionStart;
dp+=strlen(dp)+1; dp+=strlen(dp)+1;
char * pItems = dp, * pItemStart; char * pItems = dp, * pItemStart;
@@ -9299,7 +9300,7 @@ char * parseExtendedEvents(char * dp, CEPGData * epgdata) {
char pp = *pItemDescriptions; char pp = *pItemDescriptions;
*pItemDescriptions = 0; *pItemDescriptions = 0;
epgdata->itemDescriptions.push_back(pItemDescriptionStart); epgdata->itemDescriptions.push_back(pItemDescriptionStart);
/*printf("CSectionsdClient::parseExtendedEvents: desc %s\n", pItemDescriptionStart);*/ /*printf("CSectionsdClient::parseExtendedEvents: desc %s\n", pItemDescriptionStart);*/
if(!pp) if(!pp)
break; break;
pItemDescriptions++; pItemDescriptions++;
@@ -9314,18 +9315,18 @@ char * parseExtendedEvents(char * dp, CEPGData * epgdata) {
char pp = *pItemDescriptions; char pp = *pItemDescriptions;
*pItems = 0; *pItems = 0;
epgdata->items.push_back(pItemStart); epgdata->items.push_back(pItemStart);
/*printf("CSectionsdClient::parseExtendedEvents: item %s\n", pItemStart);*/ /*printf("CSectionsdClient::parseExtendedEvents: item %s\n", pItemStart);*/
if(!pp) if(!pp)
break; break;
pItems++; pItems++;
} }
return dp; return dp;
} }
#endif #endif
/*was getEPGid commandEPGepgID(int connfd, char *data, const unsigned dataLength) */ /*was getEPGid commandEPGepgID(int connfd, char *data, const unsigned dataLength) */
bool sectionsd_getEPGid(const event_id_t epgID, const time_t startzeit, CEPGData * epgdata) bool sectionsd_getEPGid(const event_id_t epgID, const time_t startzeit, CEPGData * epgdata)
{ {
bool ret = false; bool ret = false;
dprintf("Request of actual EPG for 0x%llx 0x%lx\n", epgID, startzeit); dprintf("Request of actual EPG for 0x%llx 0x%lx\n", epgID, startzeit);
@@ -9366,10 +9367,10 @@ bool sectionsd_getEPGid(const event_id_t epgID, const time_t startzeit, CEPGData
} }
unlockEvents(); unlockEvents();
return ret; return ret;
} }
/* was commandActualEPGchannelID(int connfd, char *data, const unsigned dataLength) */ /* was commandActualEPGchannelID(int connfd, char *data, const unsigned dataLength) */
bool sectionsd_getActualEPGServiceKey(const t_channel_id uniqueServiceKey, CEPGData * epgdata) bool sectionsd_getActualEPGServiceKey(const t_channel_id uniqueServiceKey, CEPGData * epgdata)
{ {
bool ret = false; bool ret = false;
SIevent evt; SIevent evt;
SItime zeit(0, 0); SItime zeit(0, 0);
@@ -9408,7 +9409,7 @@ bool sectionsd_getActualEPGServiceKey(const t_channel_id uniqueServiceKey, CEPGD
epgdata->title = evt.getName(); epgdata->title = evt.getName();
epgdata->info1 = evt.getText(); epgdata->info1 = evt.getText();
epgdata->info2 = evt.getExtendedText(); epgdata->info2 = evt.getExtendedText();
/* FIXME printf("itemDescription: %s\n", evt.itemDescription.c_str());*/ /* FIXME printf("itemDescription: %s\n", evt.itemDescription.c_str());*/
epgdata->contentClassification = std::string(evt.contentClassification.data(), evt.contentClassification.length()); epgdata->contentClassification = std::string(evt.contentClassification.data(), evt.contentClassification.length());
epgdata->userClassification = std::string(evt.userClassification.data(), evt.userClassification.length()); epgdata->userClassification = std::string(evt.userClassification.data(), evt.userClassification.length());
epgdata->fsk = evt.getFSK(); epgdata->fsk = evt.getFSK();
@@ -9423,10 +9424,10 @@ bool sectionsd_getActualEPGServiceKey(const t_channel_id uniqueServiceKey, CEPGD
unlockEvents(); unlockEvents();
return ret; return ret;
} }
/* was static void sendEventList(int connfd, const unsigned char serviceTyp1, const unsigned char serviceTyp2 = 0, int sendServiceName = 1, t_channel_id * chidlist = NULL, int clen = 0) */ /* was static void sendEventList(int connfd, const unsigned char serviceTyp1, const unsigned char serviceTyp2 = 0, int sendServiceName = 1, t_channel_id * chidlist = NULL, int clen = 0) */
void sectionsd_getChannelEvents(CChannelEventList &eList, const bool tv_mode = true, t_channel_id *chidlist = NULL, int clen = 0) void sectionsd_getChannelEvents(CChannelEventList &eList, const bool tv_mode = true, t_channel_id *chidlist = NULL, int clen = 0)
{ {
unsigned char serviceTyp1, serviceTyp2; unsigned char serviceTyp1, serviceTyp2;
clen = clen / sizeof(t_channel_id); clen = clen / sizeof(t_channel_id);
@@ -9506,10 +9507,10 @@ void sectionsd_getChannelEvents(CChannelEventList &eList, const bool tv_mode = t
} }
unlockEvents(); unlockEvents();
} }
/*was static void commandComponentTagsUniqueKey(int connfd, char *data, const unsigned dataLength) */ /*was static void commandComponentTagsUniqueKey(int connfd, char *data, const unsigned dataLength) */
bool sectionsd_getComponentTagsUniqueKey(const event_id_t uniqueKey, CSectionsdClient::ComponentTagList& tags) bool sectionsd_getComponentTagsUniqueKey(const event_id_t uniqueKey, CSectionsdClient::ComponentTagList& tags)
{ {
bool ret = false; bool ret = false;
dprintf("Request of ComponentTags for 0x%llx\n", uniqueKey); dprintf("Request of ComponentTags for 0x%llx\n", uniqueKey);
@@ -9536,10 +9537,10 @@ bool sectionsd_getComponentTagsUniqueKey(const event_id_t uniqueKey, CSectionsdC
unlockEvents(); unlockEvents();
return ret; return ret;
} }
/* was static void commandLinkageDescriptorsUniqueKey(int connfd, char *data, const unsigned dataLength) */ /* was static void commandLinkageDescriptorsUniqueKey(int connfd, char *data, const unsigned dataLength) */
bool sectionsd_getLinkageDescriptorsUniqueKey(const event_id_t uniqueKey, CSectionsdClient::LinkageDescriptorList& descriptors) bool sectionsd_getLinkageDescriptorsUniqueKey(const event_id_t uniqueKey, CSectionsdClient::LinkageDescriptorList& descriptors)
{ {
bool ret = false; bool ret = false;
dprintf("Request of LinkageDescriptors for 0x%llx\n", uniqueKey); dprintf("Request of LinkageDescriptors for 0x%llx\n", uniqueKey);
@@ -9567,10 +9568,10 @@ bool sectionsd_getLinkageDescriptorsUniqueKey(const event_id_t uniqueKey, CSecti
unlockEvents(); unlockEvents();
return ret; return ret;
} }
/* was static void commandTimesNVODservice(int connfd, char *data, const unsigned dataLength) */ /* was static void commandTimesNVODservice(int connfd, char *data, const unsigned dataLength) */
bool sectionsd_getNVODTimesServiceKey(const t_channel_id uniqueServiceKey, CSectionsdClient::NVODTimesList& nvod_list) bool sectionsd_getNVODTimesServiceKey(const t_channel_id uniqueServiceKey, CSectionsdClient::NVODTimesList& nvod_list)
{ {
bool ret = false; bool ret = false;
dprintf("Request of NVOD times for " PRINTF_CHANNEL_ID_TYPE "\n", uniqueServiceKey); dprintf("Request of NVOD times for " PRINTF_CHANNEL_ID_TYPE "\n", uniqueServiceKey);
@@ -9606,10 +9607,10 @@ bool sectionsd_getNVODTimesServiceKey(const t_channel_id uniqueServiceKey, CSect
unlockEvents(); unlockEvents();
unlockServices(); unlockServices();
return ret; return ret;
} }
void sectionsd_setPrivatePid(unsigned short /*pid*/) void sectionsd_setPrivatePid(unsigned short /*pid*/)
{ {
#ifdef ENABLE_PPT #ifdef ENABLE_PPT
privatePid = pid; privatePid = pid;
if (pid != 0) { if (pid != 0) {
@@ -9617,10 +9618,10 @@ void sectionsd_setPrivatePid(unsigned short /*pid*/)
dmxPPT.change( 0 ); dmxPPT.change( 0 );
} }
#endif #endif
} }
void sectionsd_set_languages(const std::vector<std::string>& newLanguages) void sectionsd_set_languages(const std::vector<std::string>& newLanguages)
{ {
SIlanguage::setLanguages(newLanguages); SIlanguage::setLanguages(newLanguages);
SIlanguage::saveLanguages(); SIlanguage::saveLanguages();
} }