mirrors/neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-neutrino/neutrino.git synced 2025-08-27 15:32:59 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
66535cfc934735f9a99fc0477b05198c06d4dfe3
neutrino/src/sectionsd/SIsections.cpp
focus 66535cfc93 Remove newline from event name; Up to date encoding.conf from enigma 
git-svn-id: file:///home/bas/coolstream_public_svn/THIRDPARTY/applications/neutrino-experimental@474 e54a6e83-5905-42d5-8d5c-058d10e6a962
2010-03-11 17:39:49 +00:00

1597 lines
55 KiB
C++
Raw Blame History

//
// $Id: SIsections.cpp,v 1.61 2009/09/04 18:37:00 dbt Exp $
//
// classes for SI sections (dbox-II-project)
//
// Homepage: http://dbox2.elxsi.de
//
// Copyright (C) 2001 fnbrd (fnbrd@gmx.de)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/poll.h> // fuer poll()
#include <set>
#include <algorithm>
#include <string>
#include "SIutils.hpp"
#include "SIservices.hpp"
#include "SIevents.hpp"
#ifdef UPDATE_NETWORKS
#include "SIbouquets.hpp"
#include "SInetworks.hpp"
#endif
#include "SIsections.hpp"
#include <dmxapi.h>
#include <zapit/dvbstring.h>
#include <edvbstring.h>
#ifdef ENABLE_FREESATEPG
#include "FreesatTables.hpp"
#endif
#define NOVA 0x3ffe
#define CANALDIGITAAL 0x3fff
//#define DEBUG
struct descr_generic_header {
unsigned descriptor_tag : 8;
unsigned descriptor_length : 8;
} __attribute__ ((packed)) ;
struct descr_short_event_header {
unsigned descriptor_tag : 8;
unsigned descriptor_length : 8;
unsigned language_code_hi : 8;
unsigned language_code_mid : 8;
unsigned language_code_lo : 8;
unsigned event_name_length : 8;
} __attribute__ ((packed)) ;
struct descr_service_header {
unsigned descriptor_tag : 8;
unsigned descriptor_length : 8;
unsigned service_typ : 8;
unsigned service_provider_name_length : 8;
} __attribute__ ((packed)) ;
struct descr_extended_event_header {
unsigned descriptor_tag : 8;
unsigned descriptor_length : 8;
unsigned descriptor_number : 4;
unsigned last_descriptor_number : 4;
unsigned iso_639_2_language_code_hi : 8;
unsigned iso_639_2_language_code_mid : 8;
unsigned iso_639_2_language_code_lo : 8;
unsigned length_of_items : 8;
} __attribute__ ((packed)) ;
struct service_list_entry {
unsigned service_id_hi : 8;
unsigned service_id_lo : 8;
unsigned service_type : 8;
} __attribute__ ((packed)) ;
struct digplus_order_entry {
unsigned service_id_hi : 8;
unsigned service_id_lo : 8;
unsigned channel_number_hi : 8;
unsigned channel_number_lo : 8;
} __attribute__ ((packed)) ;
struct bskyb_order_entry {
unsigned service_id_hi : 8;
unsigned service_id_lo : 8;
unsigned service_type : 8;
unsigned unknown1 : 8;
unsigned unknown2 : 8;
unsigned channel_number_hi : 8;
unsigned channel_number_lo : 8;
unsigned unknown3 : 8;
unsigned unknown4 : 8;
} __attribute__ ((packed)) ;
struct bskyb_bid {
unsigned unknown1 : 8;
unsigned unknown2 : 8;
} __attribute__ ((packed)) ;
struct private_data_specifier {
unsigned byte1 : 8;
unsigned byte2 : 8;
unsigned byte3 : 8;
unsigned byte4 : 8;
} __attribute__ ((packed)) ;
inline unsigned min(unsigned a, unsigned b)
{
return b < a ? b : a;
}
static int get_table(unsigned char hi, unsigned char mid, unsigned char lo)
{
char lang[4];
lang[0] = hi; lang[1] = mid; lang[2] = lo; lang[3] = 0;
if(!strcmp(lang, "pol"))
return 2;
else if(!strcmp(lang, "tur"))
return 9;
else if(!strcmp(lang, "gre"))
return 7;
else if(!strcmp(lang, "rus"))
return 5;
else if(!strcmp(lang, "bul"))
return 5;
else if(!strcmp(lang, "ara"))
return 6;
return 0;
}
bool check_blacklisted(const t_original_network_id onid, const t_transport_stream_id tsid)
{
if ( (onid == 0x0001) &&
((tsid == 0x03F0) || (tsid == 0x0408) || (tsid == 0x040E) || (tsid == 0x0412) || (tsid == 0x0416) || (tsid == 0x041E) ||
(tsid == 0x0420) || (tsid == 0x0422) || (tsid == 0x0424) || (tsid == 0x0444) ))
return true;
else
return false;
}
//-----------------------------------------------------------------------
// Da es vorkommen kann das defekte Packete empfangen werden
// sollte hier alles ueberprueft werden.
// Leider ist das noch nicht bei allen Descriptoren so.
//-----------------------------------------------------------------------
void SIsectionEIT::parseLinkageDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
if(maxlen>=sizeof(struct descr_linkage_header))
{
SIlinkage l((const struct descr_linkage_header *)buf);
e.linkage_descs.insert(e.linkage_descs.end(), l);
//printf("LinkName: %s\n", l.name.c_str());
}
}
void SIsectionEIT::parseComponentDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
if(maxlen>=sizeof(struct descr_component_header))
e.components.insert(SIcomponent((const struct descr_component_header *)buf));
}
void SIsectionEIT::parseContentDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_generic_header *cont=(struct descr_generic_header *)buf;
if(cont->descriptor_length+sizeof(struct descr_generic_header)>maxlen)
return; // defekt
const char *classification=buf+sizeof(struct descr_generic_header);
while(classification<=buf+sizeof(struct descr_generic_header)+cont->descriptor_length-2) {
e.contentClassification+=std::string(classification, 1);
// printf("Content: 0x%02hhx\n", *classification);
e.userClassification+=std::string(classification+1, 1);
// printf("User: 0x%02hhx\n", *(classification+1));
classification+=2;
}
}
void SIsectionEIT::parseParentalRatingDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_generic_header *cont=(struct descr_generic_header *)buf;
if(cont->descriptor_length+sizeof(struct descr_generic_header)>maxlen)
return; // defekt
const char *s=buf+sizeof(struct descr_generic_header);
while(s<buf+sizeof(struct descr_generic_header)+cont->descriptor_length-4) {
e.ratings.insert(SIparentalRating(std::string(s, 3), *(s+3)));
s+=4;
}
}
void SIsectionEIT::parseExtendedEventDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_extended_event_header *evt=(struct descr_extended_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_extended_event_header)-sizeof(descr_generic_header)))
return; // defekt
unsigned char *items=(unsigned char *)(buf+sizeof(struct descr_extended_event_header));
int tsidonid = (e.transport_stream_id << 16) | e.original_network_id;
int table = get_table(evt->iso_639_2_language_code_hi, evt->iso_639_2_language_code_mid, evt->iso_639_2_language_code_lo);
char lang[] = {tolower(evt->iso_639_2_language_code_hi), tolower(evt->iso_639_2_language_code_mid), tolower(evt->iso_639_2_language_code_lo), '\0'};
std::string language(lang);
while(items < (unsigned char *)(buf + sizeof(struct descr_extended_event_header) + evt->length_of_items)) {
// TODO What info should be in item & itemDescription?
// Should I make language filter those as well? Arzka
if(*items) {
#if 0
if(*(items+1) < 0x06) { // other code table
// 21.07.2005 - collect all extended events in one
// string, delimit multiple entries with a newline
e.itemDescription.append(std::string((const char *)(items+2), min(maxlen-((const char *)items+2-buf), (*items)-1)));
e.itemDescription.append("\n");
}
else
#endif
{
// 21.07.2005 - collect all extended events in one
// string, delimit multiple entries with a newline
//e.itemDescription.append(std::string((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items)));
e.itemDescription.append(convertDVBUTF8((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items), table, tsidonid));
e.itemDescription.append("\n");
}
}
items+=1+*items;
if(*items) {
// 21.07.2005 - collect all extended events in one
// string, delimit multiple entries with a newline
//e.item.append(std::string((const char *)(items+0), min(maxlen-((const char *)items+1-buf), *items)));
e.item.append(convertDVBUTF8((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items), table, tsidonid));
e.item.append("\n");
}
items+=1+*items;
}
// if (0 != e.itemDescription.length()) {
// printf("Item Description: %s\n", e.itemDescription.c_str());
// printf("Item: %s\n", e.item.c_str());
// }
if(*items) {
#if 0
if(*(items+1) < 0x06) { // other code table
e.appendExtendedText(language, std::string((const char *)(items+2), min(maxlen-((const char *)items+2-buf), (*items)-1)));
} else
#endif
{
//e.appendExtendedText(language, std::string((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items)));
e.appendExtendedText(language, convertDVBUTF8((const char *)(items+1), min(maxlen-((const char *)items+1-buf), (*items)), table, tsidonid));
// printf("Extended Text: %s\n", e.extendedText.c_str());
}
}
}
#ifdef ENABLE_FREESATEPG
std::string SIsectionEIT::freesatHuffmanDecode(std::string input)
{
const char *src = input.c_str();
uint size = input.length();
if (src[1] == 1 || src[1] == 2)
{
std::string uncompressed(size * 3, ' ');
uint p = 0;
struct hufftab *table;
unsigned table_length;
if (src[1] == 1)
{
table = fsat_huffman1;
table_length = sizeof(fsat_huffman1) / sizeof(fsat_huffman1[0]);
}
else
{
table = fsat_huffman2;
table_length = sizeof(fsat_huffman2) / sizeof(fsat_huffman2[0]);
}
unsigned value = 0, byte = 2, bit = 0;
while (byte < 6 && byte < size)
{
value |= src[byte] << ((5-byte) * 8);
byte++;
}
char lastch = START;
do
{
bool found = false;
unsigned bitShift = 0;
if (lastch == ESCAPE)
{
found = true;
// Encoded in the next 8 bits.
// Terminated by the first ASCII character.
char nextCh = (value >> 24) & 0xff;
bitShift = 8;
if ((nextCh & 0x80) == 0)
lastch = nextCh;
if (p >= uncompressed.length())
uncompressed.resize(p+10);
uncompressed[p++] = nextCh;
}
else
{
for (unsigned j = 0; j < table_length; j++)
{
if (table[j].last == lastch)
{
unsigned mask = 0, maskbit = 0x80000000;
for (short kk = 0; kk < table[j].bits; kk++)
{
mask |= maskbit;
maskbit >>= 1;
}
if ((value & mask) == table[j].value)
{
char nextCh = table[j].next;
bitShift = table[j].bits;
if (nextCh != STOP && nextCh != ESCAPE)
{
if (p >= uncompressed.length())
uncompressed.resize(p+10);
uncompressed[p++] = nextCh;
}
found = true;
lastch = nextCh;
break;
}
}
}
}
if (found)
{
// Shift up by the number of bits.
for (unsigned b = 0; b < bitShift; b++)
{
value = (value << 1) & 0xfffffffe;
if (byte < size)
value |= (src[byte] >> (7-bit)) & 1;
if (bit == 7)
{
bit = 0;
byte++;
}
else bit++;
}
}
else
{
// Entry missing in table.
uncompressed.resize(p);
uncompressed.append("...");
return uncompressed;
}
} while (lastch != STOP && value != 0);
uncompressed.resize(p);
return uncompressed;
}
else return input;
}
#endif
void SIsectionEIT::parseShortEventDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_short_event_header *evt=(struct descr_short_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_short_event_header)-sizeof(descr_generic_header)))
return; // defekt
int tsidonid = (e.transport_stream_id << 16) | e.original_network_id;
int table = get_table(evt->language_code_hi, evt->language_code_mid, evt->language_code_lo);
char lang[] = {tolower(evt->language_code_hi), tolower(evt->language_code_mid), tolower(evt->language_code_lo), '\0'};
std::string language(lang);
buf+=sizeof(struct descr_short_event_header);
if(evt->event_name_length) {
#if 0
if(*buf < 0x06) { // other code table
#ifdef ENABLE_FREESATEPG
e.setName(language, buf[1] == 0x1f ? freesatHuffmanDecode(std::string(buf+1, evt->event_name_length-1)) : std::string(buf+1, evt->event_name_length-1));
#else
e.setName(language, std::string(buf+1, evt->event_name_length-1));
#endif
} else
#endif // 0
{
#ifdef ENABLE_FREESATEPG
// FIXME convertDVBUTF8
e.setName(language, buf[0] == 0x1f ? freesatHuffmanDecode(std::string(buf, evt->event_name_length)) : std::string(buf, evt->event_name_length));
#else
//e.setName(language, std::string(buf, evt->event_name_length));
e.setName(language, convertDVBUTF8(buf, evt->event_name_length, table, tsidonid));
#endif
}
}
buf+=evt->event_name_length;
unsigned char textlength=*((unsigned char *)buf);
if(textlength > 2) {
#if 0
if(*(buf+1) < 0x06) {// other code table
#ifdef ENABLE_FREESATEPG
e.setText(language, buf[2] == 0x1f ? freesatHuffmanDecode(std::string((++buf)+1, textlength-1)) : std::string((++buf)+1, textlength-1));
#else
e.setText(language, std::string((++buf)+1, textlength-1));
#endif
} else
#endif // 0
{
#ifdef ENABLE_FREESATEPG
e.setText(language, buf[1] == 0x1f ? freesatHuffmanDecode(std::string(++buf, textlength)) : std::string(++buf, textlength));
#else
//e.setText(language, std::string(++buf, textlength));
e.setText(language, convertDVBUTF8((++buf), textlength, table, tsidonid));
#endif
}
}
// printf("Name: %s\n", e.name.c_str());
// printf("Text: %s\n", e.text.c_str());
}
void SIsectionEIT::parseDescriptors(const char *des, unsigned len, SIevent &e)
{
struct descr_generic_header *desc;
/* we pass the buffer including the eit_event header, so we have to
skip it here... */
des += sizeof(struct eit_event);
len -= sizeof(struct eit_event);
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des;
// printf("Type: %s\n", decode_descr(desc->descriptor_tag));
if(desc->descriptor_tag==0x4D)
parseShortEventDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x4E)
parseExtendedEventDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x54)
parseContentDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x50)
parseComponentDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x55)
parseParentalRatingDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x4A)
parseLinkageDescriptor((const char *)desc, e, len);
if((unsigned)(desc->descriptor_length+2)>len)
break;
len-=desc->descriptor_length+2;
des+=desc->descriptor_length+2;
}
}
// Die infos aus dem Puffer holen
void SIsectionEIT::parse(void)
{
const char *actPos;
const char *bufEnd;
struct eit_event *evt;
unsigned short descriptors_loop_length;
if (!buffer || parsed)
return;
if (bufferLength < sizeof(SI_section_EIT_header) + sizeof(struct eit_event)) {
bufferLength=0;
return;
}
actPos = buffer + sizeof(SI_section_EIT_header);
bufEnd = buffer + bufferLength;
while (actPos < bufEnd - sizeof(struct eit_event)) {
evt = (struct eit_event *) actPos;
SIevent e(evt);
e.service_id = service_id();
e.original_network_id = original_network_id();
e.transport_stream_id = transport_stream_id();
descriptors_loop_length = sizeof(struct eit_event) + ((evt->descriptors_loop_length_hi << 8) | evt->descriptors_loop_length_lo);
parseDescriptors(actPos, min((unsigned)(bufEnd - actPos), descriptors_loop_length), e);
evts.insert(e);
actPos += descriptors_loop_length;
}
parsed = 1;
}
//-----------------------------------------------------------------------
// Da es vorkommen kann das defekte Packete empfangen werden
// sollte hier alles ueberprueft werden.
// Leider ist das noch nicht bei allen Descriptoren so.
//-----------------------------------------------------------------------
#ifdef ENABLE_PPT
void SIsectionPPT::parseLinkageDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
if(maxlen>=sizeof(struct descr_linkage_header))
{
SIlinkage l((const struct descr_linkage_header *)buf);
e.linkage_descs.insert(e.linkage_descs.end(), l);
// printf("LinkName: %s\n", l.name.c_str());
}
}
void SIsectionPPT::parseComponentDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
if(maxlen>=sizeof(struct descr_component_header))
e.components.insert(SIcomponent((const struct descr_component_header *)buf));
}
void SIsectionPPT::parseContentDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_generic_header *cont=(struct descr_generic_header *)buf;
if(cont->descriptor_length+sizeof(struct descr_generic_header)>maxlen)
return; // defekt
const char *classification=buf+sizeof(struct descr_generic_header);
while(classification<=buf+sizeof(struct descr_generic_header)+cont->descriptor_length-2) {
e.contentClassification+=std::string(classification, 1);
// printf("Content: 0x%02hhx\n", *classification);
e.userClassification+=std::string(classification+1, 1);
// printf("User: 0x%02hhx\n", *(classification+1));
classification+=2;
}
}
void SIsectionPPT::parseParentalRatingDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_generic_header *cont=(struct descr_generic_header *)buf;
if(cont->descriptor_length+sizeof(struct descr_generic_header)>maxlen)
return; // defekt
const char *s=buf+sizeof(struct descr_generic_header);
while(s<buf+sizeof(struct descr_generic_header)+cont->descriptor_length-4) {
e.ratings.insert(SIparentalRating(std::string(s, 3), *(s+3)));
s+=4;
}
}
void SIsectionPPT::parseExtendedEventDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_extended_event_header *evt=(struct descr_extended_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_extended_event_header)-sizeof(descr_generic_header)))
return; // defekt
std::string language;
language += evt->iso_639_2_language_code_hi + evt->iso_639_2_language_code_mid + evt->iso_639_2_language_code_lo;
unsigned char *items=(unsigned char *)(buf+sizeof(struct descr_extended_event_header));
while(items<(unsigned char *)(buf+sizeof(struct descr_extended_event_header)+evt->length_of_items)) {
if(*items) {
if(*(items+1) < 0x06) // other code table
e.itemDescription=std::string((const char *)(items+2), min(maxlen-((const char *)items+2-buf), (*items)-1));
else
e.itemDescription=std::string((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items));
// printf("Item Description: %s\n", e.itemDescription.c_str());
}
items+=1+*items;
if(*items) {
e.item=std::string((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items));
// printf("Item: %s\n", e.item.c_str());
}
items+=1+*items;
}
if(*items) {
if(*(items+1) < 0x06) // other code table
e.appendExtendedText(language, std::string((const char *)(items+2),min(maxlen-((const char *)items+2-buf), (*items)-1)));
else
e.appendExtendedText(language, std::string((const char *)(items+1), min(maxlen-((const char *)items+1-buf), *items)));
// printf("Extended Text: %s\n", e.extendedText.c_str());
}
}
void SIsectionPPT::parseShortEventDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_short_event_header *evt=(struct descr_short_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_short_event_header)-sizeof(descr_generic_header)))
return; // defekt
std::string language;
language += evt->language_code_hi + evt->language_code_mid + evt->language_code_lo;
buf+=sizeof(struct descr_short_event_header);
if(evt->event_name_length) {
if(*buf < 0x06) // other code table
e.setName(language, std::string(buf+1, evt->event_name_length-1));
else
e.setName(language, std::string(buf, evt->event_name_length));
}
buf+=evt->event_name_length;
unsigned char textlength=*((unsigned char *)buf);
if(textlength > 2) {
if(*(buf+1) < 0x06) // other code table
e.setText(language, std::string((++buf)+1, textlength-1));
else
e.setText(language, std::string(++buf, textlength));
}
// printf("Name: %s\n", e.name.c_str());
// printf("Text: %s\n", e.text.c_str());
}
void SIsectionPPT::parsePrivateContentOrderDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_short_event_header *evt=(struct descr_short_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_short_event_header)-sizeof(descr_generic_header)))
return; // defekt
#if 0
// to be done
unsigned char Order_number_length;
char Order_number[Order_number_length];
unsigned char Order_price_length;
char Order_price[Order_price_length];
unsigned char Order_phone_number_length;
char Order_phone_number[Order_phone_number_length];
unsigned char SMS_order_information_length;
char SMS_order_information[SMS_order_information_length];
unsigned char URL_order_information_length;
char URL_order_information[URL_order_information_length];
#endif
}
void SIsectionPPT::parsePrivateParentalInformationDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
struct descr_short_event_header *evt=(struct descr_short_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_short_event_header)-sizeof(descr_generic_header)))
return; // defekt
buf+=sizeof(struct descr_generic_header);
if (sizeof(struct descr_generic_header)+1 < evt->descriptor_length) {
e.ratings.insert(SIparentalRating(std::string("", 0), *(buf)));
}
#if 0
unsigned char rating;
unsigned char Controll_time_t1[3]; // BCD coded
unsigned char Controll_time_t2[3]; // BCD coded
unsigned char Parental_information_length;
unsigned char Parental_information[Parental_information_length];
#endif
}
void SIsectionPPT::parsePrivateContentTransmissionDescriptor(const char *buf, SIevent &e, unsigned maxlen)
{
unsigned short starttime_loop_length = 0;
unsigned char tm_buf[6];
int i;
struct descr_short_event_header *evt=(struct descr_short_event_header *)buf;
if((evt->descriptor_length+sizeof(descr_generic_header)>maxlen) || (evt->descriptor_length<sizeof(struct descr_short_event_header)-sizeof(descr_generic_header)))
return; // defekt
//printf("parsePrivateContentTransmissionDescriptor\n");
const char *p=buf+sizeof(struct descr_generic_header);
if (sizeof(struct descr_generic_header)+1 <= maxlen) e.transport_stream_id = ((*p)<<8) | (*(p+1));
if (sizeof(struct descr_generic_header)+3 <= maxlen) e.original_network_id = ((*(p+2))<<8) | (*(p+3));
if (sizeof(struct descr_generic_header)+5 <= maxlen) e.service_id = ((*(p+4))<<8) | (*(p+5));
p += 6;
while(p+6 <= buf + evt->descriptor_length + sizeof(struct descr_generic_header)) {// at least one startdate/looplength/time entry
tm_buf[0] = *(p);
tm_buf[1] = *(p+1);
starttime_loop_length = (*(p+2))/3;
for (i=0;i<starttime_loop_length; i++) {
tm_buf[2] = *(p+3*i+3);
tm_buf[3] = *(p+3*i+4);
tm_buf[4] = *(p+3*i+5);
e.times.insert(SItime(changeUTCtoCtime(tm_buf), duration()));
}
p+=3 + 3*starttime_loop_length; // goto next starttime entry
}
// fake linkage !?
SIlinkage l;
l.linkageType = 0; // no linkage descriptor
l.transportStreamId = e.transport_stream_id;
l.originalNetworkId = e.original_network_id;
l.serviceId = e.service_id;
e.linkage_descs.insert(e.linkage_descs.end(), l);
}
void SIsectionPPT::parseDescriptors(const char *des, unsigned len, SIevent &e)
{
struct descr_generic_header *desc;
bool linkage_alreadyseen = false;
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des;
// printf("Type: %s\n", decode_descr(desc->descriptor_tag));
if(desc->descriptor_tag==0x4D)
parseShortEventDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x4E)
parseExtendedEventDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x54)
parseContentDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x50)
parseComponentDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x55)
parseParentalRatingDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0x4A)
parseLinkageDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0xF0)
parsePrivateContentOrderDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0xF1)
parsePrivateParentalInformationDescriptor((const char *)desc, e, len);
else if(desc->descriptor_tag==0xF2) {
if (linkage_alreadyseen) {
// Private EPG can have two linkage descriptors with their own date/time parameters for one event
// not sure if current event system supports it therefore:
// Generate additional Event(s) if there are more than one linkage descriptor (for repeated transmission)
SIevent e2(e);
e2.linkage_descs.clear();
e2.times.clear();
parsePrivateContentTransmissionDescriptor((const char *)desc, e2, len);
evts.insert(e2);
} else {
parsePrivateContentTransmissionDescriptor((const char *)desc, e, len);
linkage_alreadyseen = true;
}
}
if((unsigned)(desc->descriptor_length+2)>len)
break;
len-=desc->descriptor_length+2;
des+=desc->descriptor_length+2;
}
}
// Die infos aus dem Puffer holen
void SIsectionPPT::parse(void)
{
const char *actPos;
unsigned short descriptors_loop_length;
if (!buffer || parsed)
return;
if (bufferLength < sizeof(SI_section_PPT_header)) {
bufferLength=0;
return;
}
actPos = &buffer[sizeof(SI_section_PPT_header)];
/*while (actPos < &buffer[bufferLength])*/ {
SIevent e;
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()); // ??
parseDescriptors(actPos, min((unsigned)(buffer + bufferLength - actPos), descriptors_loop_length), e);
evts.insert(e);
actPos += descriptors_loop_length;
}
parsed = 1;
}
#endif
/********************/
void SIsectionSDT::parseNVODreferenceDescriptor(const char *buf, SIservice &s)
{
struct descr_generic_header *hdr=(struct descr_generic_header *)buf;
unsigned short *spointer=(unsigned short *)(buf+sizeof(struct descr_generic_header));
while((const char *)spointer<=buf+sizeof(struct descr_generic_header)+hdr->descriptor_length-2) {
unsigned short transportStreamID=*spointer++;
unsigned short originalNetworkID=*spointer++;
unsigned short sID=*spointer++;
s.nvods.insert(SInvodReference(transportStreamID, originalNetworkID, sID));
}
}
void SIsectionSDT::parseServiceDescriptor(const char *buf, SIservice &s)
{
bool is_blacklisted;
struct descr_service_header *sv=(struct descr_service_header *)buf;
buf+=sizeof(struct descr_service_header);
s.serviceTyp=sv->service_typ;
is_blacklisted = check_blacklisted(s.original_network_id, s.transport_stream_id);
if(sv->service_provider_name_length) {
//if(*buf < 0x06) // other code table
// s.providerName=std::string(buf+1, sv->service_provider_name_length-1);
// else
// s.providerName=std::string(buf, sv->service_provider_name_length);
if ((*buf > 0x05) && (is_blacklisted))
s.providerName = CDVBString(("\x05" + std::string((const char *)(buf))).c_str(), sv->service_provider_name_length+1).getContent();
else
s.providerName = CDVBString((const char *)(buf), sv->service_provider_name_length).getContent();
}
buf+=sv->service_provider_name_length;
unsigned char servicenamelength=*((unsigned char *)buf);
if(servicenamelength) {
if ((*buf+1 > 0x05) && (is_blacklisted))
s.serviceName = CDVBString(("\x05" + std::string((const char *)(++buf))).c_str(), servicenamelength+1).getContent();
else
s.serviceName = CDVBString((const char *)(++buf), servicenamelength).getContent();
}
// printf("Provider-Name: %s\n", s.providerName.c_str());
// printf("Service-Name: %s\n", s.serviceName.c_str());
}
void SIsectionSDT::parsePrivateDataDescriptor(const char *buf, SIservice &s)
{
buf+=sizeof(struct descr_generic_header);
struct private_data_specifier *pds=(struct private_data_specifier *)buf;
if ((((((pds->byte1 << 24) | (pds->byte2 << 16)) | (pds->byte3 << 8)) | pds->byte4) == 0x000000c0) && (s.serviceTyp == 0xc3))
s.serviceTyp = 0x01;
}
void SIsectionSDT::parseDescriptors(const char *des, unsigned len, SIservice &s)
{
struct descr_generic_header *desc;
des += sizeof(struct sdt_service);
len -= sizeof(struct sdt_service);
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des;
// printf("Type: %s\n", decode_descr(desc->descriptor_tag));
// printf("Length: %hhu\n", desc->descriptor_length);
if(desc->descriptor_tag==0x48) {
// printf("Found service descriptor\n");
parseServiceDescriptor((const char *)desc, s);
}
else if(desc->descriptor_tag==0x4b) {
// printf("Found NVOD reference descriptor\n");
parseNVODreferenceDescriptor((const char *)desc, s);
}
else if(desc->descriptor_tag==0x5f) {
// printf("Found Private Data Specifier\n");
parsePrivateDataDescriptor((const char *)desc, s);
}
// hotfix for ARD crash
if ((int) len<desc->descriptor_length+2) break;
len-=desc->descriptor_length+2;
des+=desc->descriptor_length+2;
}
}
// Die infos aus dem Puffer holen
void SIsectionSDT::parse(void)
{
const char *actPos;
const char *bufEnd;
struct sdt_service *sv;
unsigned short descriptors_loop_length;
if (!buffer || parsed)
return;
if (bufferLength < sizeof(SI_section_SDT_header) + sizeof(struct sdt_service)) {
bufferLength=0;
return;
}
actPos = buffer + sizeof(SI_section_SDT_header);
bufEnd = buffer + bufferLength;
while (actPos <= bufEnd - sizeof(struct sdt_service)) {
sv = (struct sdt_service *)actPos;
SIservice s(sv);
s.original_network_id = original_network_id();
s.transport_stream_id = transport_stream_id();
descriptors_loop_length = sizeof(struct sdt_service) + ((sv->descriptors_loop_length_hi << 8) | sv->descriptors_loop_length_lo);
//printf("actpos: %p buf+bl: %p sid: %hu desclen: %hu\n", actPos, buffer+bufferLength, sv->service_id, sv->descriptors_loop_length);
parseDescriptors(actPos, min((unsigned)(bufEnd - actPos), descriptors_loop_length), s);
svs.insert(s);
actPos += descriptors_loop_length;
}
parsed = 1;
}
#ifdef UPDATE_NETWORKS
/************************************/
/*
//Within the Service List all Channels of a bouquet are specified
int SIsectionBAT::parseServiceListDescriptor(const char *buf, SIbouquet &s, int section_no, int count)
{
struct descr_generic_header *sv=(struct descr_generic_header *)buf;
buf+=sizeof(struct descr_generic_header);
unsigned short len = sv->descriptor_length;
while(len >= sizeof(struct service_list_entry)) {
struct service_list_entry *sl=(struct service_list_entry *)buf;
buf+=sizeof(struct service_list_entry);
SIbouquet bs(s);
bs.service_id=(sl->service_id_hi << 8) | sl->service_id_lo;
bs.serviceTyp=sl->service_type;
bs.position = (uint16_t) (((section_no & 0x1f) << 11) + (count & 0x7ff));
// printf("Section Number: %d Count: %d position: %04x\n", section_no, count, bs.position);
bsv.insert(bs);
len -= sizeof(struct service_list_entry);
count++;
}
return count;
}
void SIsectionBAT::parseBouquetNameDescriptor(const char *buf, SIbouquet &s)
{
struct descr_generic_header *sv=(struct descr_generic_header *)buf;
buf+=sizeof(struct descr_generic_header);
if(sv->descriptor_length) {
// if(*buf < 0x06) // other code table
// s.bouquetName=std::string(buf+1, sv->descriptor_length-1);
//else
//s.bouquetName=std::string(buf, sv->descriptor_length);
s.bouquetName = CDVBString((const char *)(buf), sv->descriptor_length).getContent();
}
//printf("Bouquet-Name: %s\n", s.bouquetName.c_str());
}
int SIsectionBAT::parseDescriptors(const char *des, unsigned len, SIbouquet &s, int section_no, int count, const char *bouquetName)
{
struct descr_generic_header *desc;
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des;
// printf("Type: %s\n", decode_descr(desc->descriptor_tag));
// printf("Length: %hhu\n", desc->descriptor_length);
if(desc->descriptor_tag==0x41) {
// printf("Found service list descriptor\n");
count = parseServiceListDescriptor((const char *)desc, s, section_no, count);
}
// else if(desc->descriptor_tag==0x47) {
// printf("Found bouquet name descriptor\n");
// parseBouquetNameDescriptor((const char *)desc, s);
// }
len-=desc->descriptor_length+2;
des+=desc->descriptor_length+2;
}
return count;
}
*/
// Die infos aus dem Puffer holen
void SIsectionBAT::parse(void)
{
const char *actPos;
struct bat_service *sv;
// struct bouquet_ident bi;
struct SI_section_BAT_header *bh;
unsigned short descriptors_loop_length;
unsigned short descriptors_length;
uint32_t current_private_data_specifier;
struct loop_len *ll;
// std::string bouquetName = "";
if (!buffer || parsed)
return;
if (bufferLength < sizeof(SI_section_BAT_header) + sizeof(struct bat_service)) {
printf("BAT fix?\n"); //No Services possible - length too short
bufferLength=0;
return;
}
actPos = &buffer[0]; // We need Bouquet ID and bouquet descriptor length from header
bh = (struct SI_section_BAT_header *)actPos; // Header
t_bouquet_id bouquet_id = (bh->bouquet_id_hi << 8) | bh->bouquet_id_lo;
// printf("hi: %hu lo: %hu\n", bh->bouquet_descriptors_length_hi, bh->bouquet_descriptors_length_lo);
descriptors_loop_length = (bh->bouquet_descriptors_length_hi << 8) | bh->bouquet_descriptors_length_lo;
// SIbouquet s((bh->bouquet_id_hi << 8) | bh->bouquet_id_lo); //Create a new Bouquet entry
// printf("ident: %hu actpos: %p buf+bl: %p desclen: %hu\n", bi.bouquet_id, actPos, buffer+bufferLength, descriptors_loop_length);
int count = 0;
//Fill out Bouquet Name
//count = parseDescriptors(((const char *)bh) + sizeof(SI_section_BAT_header), descriptors_loop_length, s, bh->section_number, count);
const char *des = ((const char *)bh) + sizeof(SI_section_BAT_header);
unsigned len = descriptors_loop_length;
struct descr_generic_header *desc;
struct descr_generic_header *privdesc = NULL;
std::string bouquetName = "";
current_private_data_specifier = 0;
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des;
if(desc->descriptor_tag==0x47) {
// printf("Found bouquet name descriptor\n");
//parseBouquetNameDescriptor((const char *)desc, s);
const char *buf = (const char *) desc;
//struct descr_generic_header *sv=(struct descr_generic_header *)buf;
buf+=sizeof(struct descr_generic_header);
if(desc->descriptor_length) {
/*
if(*buf < 0x06) // other code table
s.bouquetName=std::string(buf+1, sv->descriptor_length-1);
else
s.bouquetName=std::string(buf, sv->descriptor_length);
*/
//Mega stupid providers do not reserve their own bouquet_id
//So we do it for them... f*ck that's stupid too, but what else can we do...
if (bouquet_id == 0x0001) {
if (!strncmp((const char *) buf, "NOVA", 4))
bouquet_id = NOVA;
if (!strncmp((const char *) buf, "CanalDigitaal", 13))
bouquet_id = CANALDIGITAAL;
}
bouquetName = CDVBString((const char *)(buf), desc->descriptor_length).getContent();
}
}
if (desc->descriptor_tag == 0x5f) {
const char *buf = (const char *) desc;
//struct descr_generic_header *sv=(struct descr_generic_header *)buf;
buf+=sizeof(struct descr_generic_header);
struct private_data_specifier *pds=(struct private_data_specifier *)buf;
buf+=sizeof(struct private_data_specifier);
current_private_data_specifier=(((pds->byte1 << 24) | (pds->byte2 << 16)) | (pds->byte3 << 8)) | pds->byte4;
//printf("Private Data Specifier: %08x\n", current_private_data_specifier);
}
len-=desc->descriptor_length+2;
des+=desc->descriptor_length+2;
}
//s.bouquetName = bouquetName;
actPos += sizeof(SI_section_BAT_header) + descriptors_loop_length;
ll = (struct loop_len *)actPos;
descriptors_loop_length = (ll->descriptors_loop_length_hi << 8) | ll->descriptors_loop_length_lo; //len is not used at the moment
// printf("desclen: %hu\n", descriptors_loop_length);
actPos += sizeof(loop_len);
if (bouquet_id != 0x0001) {
while (actPos <= &buffer[bufferLength - sizeof(struct bat_service)]) {
sv = (struct bat_service *)actPos;
//s.transport_stream_id = (sv->transport_stream_id_hi << 8) | sv->transport_stream_id_lo;
//s.original_network_id = (sv->original_network_id_hi << 8) | sv->original_network_id_lo;
// s.position = (uint16_t) (((bh->section_number & 0x1f) << 11) + (count & 0x7ff));
// printf("Section Number: %d Count: %d position: %04x\n", bh->section_number, count, s.position);
descriptors_length = (sv->descriptors_loop_length_hi << 8) | sv->descriptors_loop_length_lo;
// Transport Stream Loop
//count = parseDescriptors(((const char *)sv) + sizeof(struct bat_service), descriptors_length, s, bh->section_number, count,
//(const char *) bouquetName[0]);
bool found = false;
int loop_count = 1;
while (loop_count >= 0) {
const char *des_ = ((const char *)sv) + sizeof(struct bat_service);
len = descriptors_length;
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des_;
// printf("Type: %s\n", decode_descr(desc->descriptor_tag));
// printf("Length: %hhu\n", desc->descriptor_length);
const char *buf = (const char *) desc;
buf+=sizeof(struct descr_generic_header);
unsigned short dlen = desc->descriptor_length;
if ((desc->descriptor_tag==0x41) && (loop_count == 0) && (current_private_data_specifier != 0x00000002)) {
// printf("Found service list descriptor\n");
//count = parseServiceListDescriptor((const char *)desc, s, section_no, count);
//struct descr_generic_header *sv=(struct descr_generic_header *)buf;
while(dlen >= sizeof(struct service_list_entry)) {
struct service_list_entry *sl=(struct service_list_entry *)buf;
buf+=sizeof(struct service_list_entry);
SIbouquet bs(bouquet_id);
bs.bouquetName = bouquetName;
bs.transport_stream_id = (sv->transport_stream_id_hi << 8) | sv->transport_stream_id_lo;
bs.original_network_id = (sv->original_network_id_hi << 8) | sv->original_network_id_lo;
bs.service_id=(sl->service_id_hi << 8) | sl->service_id_lo;
bs.serviceTyp=sl->service_type;
bs.position = (uint16_t) (((bh->section_number & 0x1f) << 11) + (count & 0x7ff));
if (found) {
const char *privbuf = (const char *) privdesc;
privbuf+=sizeof(struct descr_generic_header);
unsigned short privdlen = privdesc->descriptor_length;
bool found_posi = false;
int order_entry_size;
order_entry_size = sizeof(struct digplus_order_entry);
while ((privdlen >= order_entry_size) && (!found_posi)) {
struct digplus_order_entry *oe = (struct digplus_order_entry *)privbuf;
privbuf+=order_entry_size;
/*
printf("Search: %04x Service_id: %04x Posi:%04x\n",
(sl->service_id_hi << 8) | sl->service_id_lo,
(oe->service_id_hi << 8) | oe->service_id_lo,
(oe->channel_number_hi << 8) | oe->channel_number_lo);
*/
if ( ((sl->service_id_hi << 8) | sl->service_id_lo) ==
((oe->service_id_hi << 8) | oe->service_id_lo)) {
bs.position = (oe->channel_number_hi << 8) | oe->channel_number_lo;
/*
printf("Found Search: %04x Service_id: %04x Posi:%04x\n",
(sl->service_id_hi << 8) | sl->service_id_lo,
current_service_id,
current_channel_number);
*/
found_posi=true;
}
privdlen -= order_entry_size;
}
if (!found_posi)
bs.position = 0xffff;
}
// printf("Section Number: %d Count: %d position: %04x\n", section_no, count, bs.position);
//printf("Set Position: %04x\n",bs.position);
bsv.insert(bs);
dlen -= sizeof(struct service_list_entry);
count++;
}
}
if (desc->descriptor_tag == 0x5f) {
struct private_data_specifier *pds=(struct private_data_specifier *)buf;
buf+=sizeof(struct private_data_specifier);
if ((pds->byte1 != 0) || (pds->byte2 != 0) || (pds->byte3 != 0) || (pds->byte4 != 0))
current_private_data_specifier=(((pds->byte1 << 24) | (pds->byte2 << 16)) |
(pds->byte3 << 8)) | pds->byte4;
//printf("Private Data Specifier: %08x\n", current_private_data_specifier);
}
if (desc->descriptor_tag == 0x81) {
if (current_private_data_specifier == 0x55504300) {
//printf("UPC Bouquet ordering descriptor found!\n");
privdesc = (struct descr_generic_header *)desc;
found = true;
}
}
if (desc->descriptor_tag == 0x82) {
if ((current_private_data_specifier == 0x00000010) || (bouquet_id == 0x0021)) {
//printf("TPS Bouquet ordering descriptor found!\n");
privdesc = (struct descr_generic_header *)desc;
found = true;
}
}
if (desc->descriptor_tag == 0x83) {
if ((current_private_data_specifier == 0x000000c0) || (current_private_data_specifier == 0x0000003a)) {
//printf("Canal+ Bouquet ordering descriptor found!\n");
privdesc = (struct descr_generic_header *)desc;
found = true;
}
}
if (desc->descriptor_tag == 0x93) {
if ((current_private_data_specifier == 0x00362275) || (bouquet_id == CANALDIGITAAL)) {
//printf("Irdeto Bouquet ordering descriptor found!\n");
privdesc = (struct descr_generic_header *)desc;
found = true;
}
}
if ((desc->descriptor_tag == 0xb1) && (loop_count == 0)) {
if (current_private_data_specifier == 0x00000002) {
//printf("BSkyB Bouquet ordering descriptor found!\n");
const char *privbuf = (const char *) desc;
privbuf+=sizeof(struct descr_generic_header);
unsigned short privdlen = desc->descriptor_length - 2;
//Nirvana 27.4.06: first 2 bytes still unknown: always 0xffff on sky italia?
//check if resulting bouquets on 28.2E look more sensible...
struct bskyb_bid *bid = (struct bskyb_bid *)privbuf;
if ((bid->unknown1 == 0xff) && (bid->unknown2 == 0xff)) {
privbuf+=2; //first 2 bytes of each 0xb1 desc unknown
while (privdlen >= sizeof(struct bskyb_order_entry)) {
struct bskyb_order_entry *oe = (struct bskyb_order_entry *)privbuf;
privbuf+=sizeof(struct bskyb_order_entry);
SIbouquet bs(bouquet_id);
bs.bouquetName = bouquetName;
bs.transport_stream_id = (sv->transport_stream_id_hi << 8) |
sv->transport_stream_id_lo;
bs.original_network_id = (sv->original_network_id_hi << 8) |
sv->original_network_id_lo;
bs.service_id = (oe->service_id_hi << 8) | oe->service_id_lo;
bs.serviceTyp = oe->service_type;
bs.position = (oe->channel_number_hi << 8) | oe->channel_number_lo;
bsv.insert(bs);
privdlen -= sizeof(struct bskyb_order_entry);
}
}
}
}
len-=desc->descriptor_length+2;
des_+=desc->descriptor_length+2;
}
loop_count--;
}
actPos += sizeof(struct bat_service) + descriptors_length;
// count++;
}
}
parsed = 1;
}
void SIsectionNIT::copyDeliveryDescriptor(const char *buf, SInetwork &s)
{
//struct descr_generic_header *sv=(struct descr_generic_header *)buf;
buf+=sizeof(struct descr_generic_header);
memcpy(s.delivery_descriptor, buf, sizeof(struct satellite_delivery_descriptor)); //same size as cable...
//printf("Bouquet-Name: %s\n", s.bouquetName.c_str());
}
void SIsectionNIT::parseDescriptors(const char *des, unsigned len, SInetwork &s)
{
// struct satellite_delivery_descriptor *sdd;
// const char *ddp;
// t_transport_stream_id tsid;
// t_original_network_id onid;
// unsigned short orbital_pos;
struct descr_generic_header *desc;
des += sizeof(struct nit_transponder);
len -= sizeof(struct nit_transponder);
while(len>=sizeof(struct descr_generic_header)) {
desc=(struct descr_generic_header *)des;
// printf("Type: %s\n", decode_descr(desc->descriptor_tag));
// printf("Length: %hhu\n", desc->descriptor_length);
if ( (desc->descriptor_tag==0x43) || (desc->descriptor_tag==0x44) ) {
s.delivery_type = desc->descriptor_tag;
// printf("Found satellite_delivery_system_descriptor\n");
copyDeliveryDescriptor((const char *)desc, s);
// ddp = &s.delivery_descriptor[0];
// sdd = (struct satellite_delivery_descriptor *)ddp;
// tsid = s.transport_stream_id;
// onid = s.original_network_id;
// orbital_pos = (sdd->orbital_pos_hi << 8) | sdd->orbital_pos_lo;
// printf("ONID: %04x TSID: %04x Orbital Position: %d\n", onid, tsid, orbital_pos);
}
len-=desc->descriptor_length+2;
des+=desc->descriptor_length+2;
}
}
// Die infos aus dem Puffer holen
void SIsectionNIT::parse(void)
{
const char *actPos;
const char *bufEnd;
struct nit_transponder *tp;
struct SI_section_NIT_header *nh;
unsigned short descriptors_loop_length;
unsigned short descriptors_length;
struct loop_len *ll;
//t_network_id network_id;
if (!buffer || parsed)
return;
if (bufferLength < sizeof(SI_section_NIT_header) + sizeof(struct nit_transponder)) {
printf("NIT fix?\n"); //No Services possible - length too short
bufferLength=0;
return;
}
actPos = buffer; // We need Bouquet ID and bouquet descriptor length from header
bufEnd = buffer + bufferLength;
nh = (struct SI_section_NIT_header *)actPos; // Header
// printf("hi: %hu lo: %hu\n", bh->bouquet_descriptors_length_hi, bh->bouquet_descriptors_length_lo);
descriptors_loop_length = (nh->network_descriptors_length_hi << 8) | nh->network_descriptors_length_lo;
// SIbouquet s((bh->bouquet_id_hi << 8) | bh->bouquet_id_lo); //Create a new Bouquet entry
// printf("ident: %hu actpos: %p buf+bl: %p desclen: %hu\n", bi.bouquet_id, actPos, buffer+bufferLength, descriptors_loop_length);
// parseDescriptors(((const char *)bh) + sizeof(SI_section_BAT_header), descriptors_loop_length, s); //Fill out Bouquet Name
actPos += sizeof(SI_section_NIT_header) + descriptors_loop_length;
ll = (struct loop_len *)actPos;
descriptors_loop_length = (ll->descriptors_loop_length_hi << 8) | ll->descriptors_loop_length_lo; //len is not used at the moment
// printf("desclen: %hu\n", descriptors_loop_length);
actPos += sizeof(loop_len);
while (actPos <= bufEnd - sizeof(struct nit_transponder)) {
tp = (struct nit_transponder *)actPos;
SInetwork s(tp);
s.network_id = (nh->network_id_hi << 8) | nh->network_id_lo;
s.transport_stream_id = (tp->transport_stream_id_hi << 8) | tp->transport_stream_id_lo;
s.original_network_id = (tp->original_network_id_hi << 8) | tp->original_network_id_lo;
descriptors_length = sizeof(struct nit_transponder) + ((tp->descriptors_loop_length_hi << 8) | tp->descriptors_loop_length_lo);
parseDescriptors(actPos, min((unsigned)(bufEnd - actPos), descriptors_length), s); // Transport Stream Loop
ntw.insert(s);
actPos += descriptors_length;
}
parsed = 1;
}
#endif
#ifndef DO_NOT_INCLUDE_STUFF_NOT_NEEDED_FOR_SECTIONSD
// Liest n Bytes aus einem Socket per read
// Liefert 0 bei timeout
// und -1 bei Fehler
// ansonsten die Anzahl gelesener Bytes
inline int readNbytes(int fd, char *buf, int n, unsigned timeoutInSeconds)
{
int j;
for(j=0; j<n;) {
struct pollfd ufds;
// memset(&ufds, 0, sizeof(ufds));
ufds.fd=fd;
ufds.events=POLLIN|POLLPRI;
ufds.revents=0;
int rc=poll(&ufds, 1, timeoutInSeconds*1000);
if(!rc)
return 0; // timeout
else if(rc<0) {
perror ("poll");
return -1;
}
int r=read (fd, buf, n-j);
if(r<=0) {
perror ("read");
return -1;
}
j+=r;
buf+=r;
}
return j;
}
//
// Beachtung der Stuffing tables (ST) fehlt noch
//
int SIsections :: readSections(const unsigned short pid, const unsigned char filter, const unsigned char mask, int readNext, unsigned timeoutInSeconds)
{
int fd;
struct SI_section_header header;
uint64_t firstKey=(uint64_t)-1;
SIsections missingSections;
char *buf;
unsigned short section_length;
if ((fd = open(DEMUX_DEVICE, O_RDWR)) == -1) {
perror(DEMUX_DEVICE);
return 1;
}
if (!setfilter(fd, pid, filter, mask, DMX_IMMEDIATE_START | DMX_CHECK_CRC)) {
close(fd);
return 2;
}
time_t szeit = time(NULL);
// Erstes Segment lesen
do {
if (time(NULL) > szeit + (long)timeoutInSeconds) {
close(fd);
return 0; // timeout -> kein EPG
}
int rc = readNbytes(fd, (char *)&header, sizeof(header), timeoutInSeconds);
if(!rc) {
close(fd);
return 0; // timeout -> kein EPG
}
else if(rc<0) {
close(fd);
//perror ("read header");
return 3;
}
section_length = (header.section_length_hi << 8) | header.section_length_lo;
buf = new char[sizeof(header) + section_length - 5];
if (!buf) {
close(fd);
fprintf(stderr, "Not enough memory!\n");
return 4;
}
// Den Header kopieren
memcpy(buf, &header, sizeof(header));
rc = readNbytes(fd, &buf[sizeof(header)], section_length - 5, timeoutInSeconds);
if (!rc) {
close(fd);
delete[] buf;
return 0; // timeout -> kein EPG
}
else if (rc<0) {
close(fd);
//perror ("read section");
delete[] buf;
return 5;
}
if ((readNext) || (header.current_next_indicator)) {
// Wir wollen nur aktuelle sections
insert(SIsection(sizeof(header) + section_length - 5, buf));
firstKey = SIsection::key(&header);
// Sonderfall: Nur eine Section
// d.h. wir sind fertig
if ((!header.section_number) && (!header.last_section_number)) {
close(fd);
return 0;
}
}
else {
delete[] buf;
}
} while (firstKey == (uint64_t) -1);
// Die restlichen Segmente lesen
szeit = time(NULL);
for (;;) {
if (time(NULL) > szeit + (long)timeoutInSeconds)
break; // timeout
int rc = readNbytes(fd, (char *)&header, sizeof(header), timeoutInSeconds);
if(!rc)
break; // timeout
else if(rc<0) {
close(fd);
//perror ("read header");
return 6;
}
if (firstKey==SIsection::key(&header))
// Wir haben die 1. section wieder gefunden
break;
section_length = (header.section_length_hi << 8) | header.section_length_lo;
buf = new char[sizeof(header) + section_length - 5];
if (!buf) {
close(fd);
fprintf(stderr, "Not enough memory!\n");
return 7;
}
// Den Header kopieren (evtl. malloc und realloc nehmen)
memcpy(buf, &header, sizeof(header));
// den Rest der Section einlesen
rc = readNbytes(fd, &buf[sizeof(header)], section_length - 5, timeoutInSeconds);
if (!rc) {
delete[] buf;
break; // timeout
}
else if (rc < 0) {
close(fd);
delete[] buf;
//perror ("read section");
return 8;
}
if ((readNext) || (header.current_next_indicator))
insert(SIsection(sizeof(header) + section_length - 5, buf));
else
delete[] buf;
}
close(fd);
#ifdef DEBUG
// Die Sections ausgeben
printf("----------------Found sections-----------------------\n");
// for_each(begin(), end(), printSIsection());
for_each(begin(), end(), printSIsectionEIT());
printf("-----------------------------------------------------\n");
#endif // DEBUG
// Jetzt erstellen wir eine Liste der fehlenden Sections
unsigned short actualTableIDextension = (unsigned short) -1;
unsigned char actualTableID = (unsigned char) -1;
unsigned char maxNr = 0;
unsigned char lastNr = 0;
for (SIsections::iterator k = begin(); k != end(); k++) {
if ((k->tableIDextension() != actualTableIDextension) || (k->tableID() != actualTableID)) {
// Neue Table-ID-Extension
maxNr = k->lastSectionNumber();
actualTableIDextension = k->tableIDextension();
actualTableID = k->tableID();
}
else if (k->sectionNumber() != (unsigned char)(lastNr + 1)) {
// Es fehlen Sections
for (unsigned l = lastNr + 1; l < k->sectionNumber(); l++) {
//printf("Debug: t: 0x%02x s: %u nr: %u last: %u max: %u l: %u\n", actualTableID, actualTableIDextension, k->sectionNumber(), lastNr, maxNr, l);
struct SI_section_header h;
memcpy(&h, k->header(), sizeof(struct SI_section_header));
h.section_number = l;
missingSections.insert(SIsection(&h));
}
}
lastNr = k->sectionNumber();
}
#ifdef DEBUG
printf("Sections read: %d\n\n", size());
#endif // DEBUG
if (!missingSections.size())
return 0;
#ifdef DEBUG
printf("----------------Missing sections---------------------\n");
for_each(missingSections.begin(), missingSections.end(), printSmallSIsectionHeader());
printf("-----------------------------------------------------\n");
printf("Sections read: %d\n\n", size());
printf("Sections misssing: %d\n", missingSections.size());
printf("Searching missing sections\n");
#endif // DEBUG
szeit = time(NULL);
if ((fd = open(DEMUX_DEVICE, O_RDWR)) == -1) {
perror(DEMUX_DEVICE);
return 9;
}
if (!setfilter(fd, pid, filter, mask, DMX_IMMEDIATE_START | DMX_CHECK_CRC)) {
close(fd);
return 10;
}
// Jetzt lesen wir die fehlenden Sections ein
for(;;) {
if (time(NULL) > szeit + (long)timeoutInSeconds)
break; // Timeout
int rc = readNbytes(fd, (char *)&header, sizeof(header), timeoutInSeconds);
if(!rc)
break; // timeout
else if (rc < 0) {
close(fd);
//perror ("read header");
return 11;
}
section_length = (header.section_length_hi << 8) | header.section_length_lo;
buf = new char[sizeof(header) + section_length - 5];
if (!buf) {
close(fd);
fprintf(stderr, "Not enough memory!\n");
return 12;
}
// Den Header kopieren (evtl. malloc und realloc nehmen)
memcpy(buf, &header, sizeof(header));
// den Rest der Section einlesen
rc = readNbytes(fd, &buf[sizeof(header)], section_length - 5, timeoutInSeconds);
if (!rc) {
delete[] buf;
break; // timeout
}
else if (rc < 0) {
close(fd);
delete[] buf;
//perror ("read section");
return 13;
}
if (missingSections.find(SIsection(&header)) != missingSections.end()) {
#ifdef DEBUG
printf("Find missing section:");
SIsection::dumpSmallSectionHeader(&header);
#endif // DEBUG
// War bisher vermisst
// In die Menge einfuegen
insert(SIsection(sizeof(header) + section_length - 5, buf));
// Und aus der vermissten Menge entfernen
missingSections.erase(SIsection(&header));
#ifdef DEBUG
printf("Sections misssing: %d\n", missingSections.size());
#endif // DEBUG
}
else {
// Puffer wieder loeschen
delete[] buf;
}
}
close(fd);
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink